1// 2package vocab 3 4import ( 5 "fmt" 6 "net/url" 7 "time" 8) 9 10// bccIntermediateType will only have one of its values set at most 11type bccIntermediateType struct { 12 // An unknown value. 13 unknown_ interface{} 14 // Stores possible ObjectType type for bcc property 15 Object ObjectType 16 // Stores possible LinkType type for bcc property 17 Link LinkType 18 // Stores possible *url.URL type for bcc property 19 IRI *url.URL 20} 21 22// Deserialize takes an interface{} and attempts to create a valid intermediate type. 23func (t *bccIntermediateType) Deserialize(i interface{}) (err error) { 24 matched := false 25 if m, ok := i.(map[string]interface{}); ok { 26 if tv, ok := m["type"]; ok { 27 var types []string 28 if tvs, ok := tv.([]interface{}); ok { 29 for _, tvi := range tvs { 30 if typeString, ok := tvi.(string); ok { 31 types = append(types, typeString) 32 } 33 } 34 } else if typeString, ok := tv.(string); ok { 35 types = append(types, typeString) 36 } 37 if !matched { 38 for _, kind := range types { 39 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 40 err = t.Object.Deserialize(m) 41 matched = true 42 break 43 } 44 } 45 } 46 if !matched { 47 for _, kind := range types { 48 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 49 err = t.Link.Deserialize(m) 50 matched = true 51 break 52 } 53 } 54 } 55 } else { 56 t.unknown_ = m 57 } 58 } else if i != nil { 59 if !matched { 60 t.IRI, err = IRIDeserialize(i) 61 if err != nil { 62 t.IRI = nil 63 } else { 64 matched = true 65 } 66 } 67 } 68 if !matched { 69 t.unknown_ = unknownValueDeserialize(i) 70 } 71 return 72 73} 74 75// Serialize turns this object into an interface{}. 76func (t *bccIntermediateType) Serialize() (i interface{}, err error) { 77 if t.Object != nil { 78 i, err = t.Object.Serialize() 79 return 80 } 81 if t.Link != nil { 82 i, err = t.Link.Serialize() 83 return 84 } 85 if t.IRI != nil { 86 i = IRISerialize(t.IRI) 87 return 88 } 89 i = unknownValueSerialize(t.unknown_) 90 return 91} 92 93// oneOfIntermediateType will only have one of its values set at most 94type oneOfIntermediateType struct { 95 // An unknown value. 96 unknown_ interface{} 97 // Stores possible ObjectType type for oneOf property 98 Object ObjectType 99 // Stores possible LinkType type for oneOf property 100 Link LinkType 101 // Stores possible *url.URL type for oneOf property 102 IRI *url.URL 103} 104 105// Deserialize takes an interface{} and attempts to create a valid intermediate type. 106func (t *oneOfIntermediateType) Deserialize(i interface{}) (err error) { 107 matched := false 108 if m, ok := i.(map[string]interface{}); ok { 109 if tv, ok := m["type"]; ok { 110 var types []string 111 if tvs, ok := tv.([]interface{}); ok { 112 for _, tvi := range tvs { 113 if typeString, ok := tvi.(string); ok { 114 types = append(types, typeString) 115 } 116 } 117 } else if typeString, ok := tv.(string); ok { 118 types = append(types, typeString) 119 } 120 if !matched { 121 for _, kind := range types { 122 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 123 err = t.Object.Deserialize(m) 124 matched = true 125 break 126 } 127 } 128 } 129 if !matched { 130 for _, kind := range types { 131 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 132 err = t.Link.Deserialize(m) 133 matched = true 134 break 135 } 136 } 137 } 138 } else { 139 t.unknown_ = m 140 } 141 } else if i != nil { 142 if !matched { 143 t.IRI, err = IRIDeserialize(i) 144 if err != nil { 145 t.IRI = nil 146 } else { 147 matched = true 148 } 149 } 150 } 151 if !matched { 152 t.unknown_ = unknownValueDeserialize(i) 153 } 154 return 155 156} 157 158// Serialize turns this object into an interface{}. 159func (t *oneOfIntermediateType) Serialize() (i interface{}, err error) { 160 if t.Object != nil { 161 i, err = t.Object.Serialize() 162 return 163 } 164 if t.Link != nil { 165 i, err = t.Link.Serialize() 166 return 167 } 168 if t.IRI != nil { 169 i = IRISerialize(t.IRI) 170 return 171 } 172 i = unknownValueSerialize(t.unknown_) 173 return 174} 175 176// closedIntermediateType will only have one of its values set at most 177type closedIntermediateType struct { 178 // An unknown value. 179 unknown_ interface{} 180 // Stores possible *time.Time type for closed property 181 dateTime *time.Time 182 // Stores possible *bool type for closed property 183 boolean *bool 184 // Stores possible ObjectType type for closed property 185 Object ObjectType 186 // Stores possible LinkType type for closed property 187 Link LinkType 188 // Stores possible *url.URL type for closed property 189 IRI *url.URL 190} 191 192// Deserialize takes an interface{} and attempts to create a valid intermediate type. 193func (t *closedIntermediateType) Deserialize(i interface{}) (err error) { 194 matched := false 195 if m, ok := i.(map[string]interface{}); ok { 196 if tv, ok := m["type"]; ok { 197 var types []string 198 if tvs, ok := tv.([]interface{}); ok { 199 for _, tvi := range tvs { 200 if typeString, ok := tvi.(string); ok { 201 types = append(types, typeString) 202 } 203 } 204 } else if typeString, ok := tv.(string); ok { 205 types = append(types, typeString) 206 } 207 if !matched { 208 for _, kind := range types { 209 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 210 err = t.Object.Deserialize(m) 211 matched = true 212 break 213 } 214 } 215 } 216 if !matched { 217 for _, kind := range types { 218 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 219 err = t.Link.Deserialize(m) 220 matched = true 221 break 222 } 223 } 224 } 225 } else { 226 t.unknown_ = m 227 } 228 } else if i != nil { 229 if !matched { 230 t.dateTime, err = dateTimeDeserialize(i) 231 if err != nil { 232 t.dateTime = nil 233 } else { 234 matched = true 235 } 236 } 237 if !matched { 238 t.boolean, err = booleanDeserialize(i) 239 if err != nil { 240 t.boolean = nil 241 } else { 242 matched = true 243 } 244 } 245 if !matched { 246 t.IRI, err = IRIDeserialize(i) 247 if err != nil { 248 t.IRI = nil 249 } else { 250 matched = true 251 } 252 } 253 } 254 if !matched { 255 t.unknown_ = unknownValueDeserialize(i) 256 } 257 return 258 259} 260 261// Serialize turns this object into an interface{}. 262func (t *closedIntermediateType) Serialize() (i interface{}, err error) { 263 if t.dateTime != nil { 264 i = dateTimeSerialize(*t.dateTime) 265 return 266 } 267 if t.boolean != nil { 268 i = booleanSerialize(*t.boolean) 269 return 270 } 271 if t.Object != nil { 272 i, err = t.Object.Serialize() 273 return 274 } 275 if t.Link != nil { 276 i, err = t.Link.Serialize() 277 return 278 } 279 if t.IRI != nil { 280 i = IRISerialize(t.IRI) 281 return 282 } 283 i = unknownValueSerialize(t.unknown_) 284 return 285} 286 287// longitudeIntermediateType will only have one of its values set at most 288type longitudeIntermediateType struct { 289 // An unknown value. 290 unknown_ interface{} 291 // Stores possible *float64 type for longitude property 292 float *float64 293 // Stores possible *url.URL type for longitude property 294 IRI *url.URL 295} 296 297// Deserialize takes an interface{} and attempts to create a valid intermediate type. 298func (t *longitudeIntermediateType) Deserialize(i interface{}) (err error) { 299 matched := false 300 if m, ok := i.(map[string]interface{}); ok { 301 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 302 } else if i != nil { 303 if !matched { 304 t.float, err = floatDeserialize(i) 305 if err != nil { 306 t.float = nil 307 } else { 308 matched = true 309 } 310 } 311 if !matched { 312 t.IRI, err = IRIDeserialize(i) 313 if err != nil { 314 t.IRI = nil 315 } else { 316 matched = true 317 } 318 } 319 } 320 if !matched { 321 t.unknown_ = unknownValueDeserialize(i) 322 } 323 return 324 325} 326 327// Serialize turns this object into an interface{}. 328func (t *longitudeIntermediateType) Serialize() (i interface{}, err error) { 329 if t.float != nil { 330 i = floatSerialize(*t.float) 331 return 332 } 333 if t.IRI != nil { 334 i = IRISerialize(t.IRI) 335 return 336 } 337 i = unknownValueSerialize(t.unknown_) 338 return 339} 340 341// nameIntermediateType will only have one of its values set at most 342type nameIntermediateType struct { 343 // An unknown value. 344 unknown_ interface{} 345 // Stores possible *string type for name property 346 stringName *string 347 // Stores possible *string type for name property 348 langString *string 349 // Stores possible *url.URL type for name property 350 IRI *url.URL 351} 352 353// Deserialize takes an interface{} and attempts to create a valid intermediate type. 354func (t *nameIntermediateType) Deserialize(i interface{}) (err error) { 355 matched := false 356 if m, ok := i.(map[string]interface{}); ok { 357 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 358 } else if i != nil { 359 if !matched { 360 t.stringName, err = stringDeserialize(i) 361 if err != nil { 362 t.stringName = nil 363 } else { 364 matched = true 365 } 366 } 367 if !matched { 368 t.langString, err = langStringDeserialize(i) 369 if err != nil { 370 t.langString = nil 371 } else { 372 matched = true 373 } 374 } 375 if !matched { 376 t.IRI, err = IRIDeserialize(i) 377 if err != nil { 378 t.IRI = nil 379 } else { 380 matched = true 381 } 382 } 383 } 384 if !matched { 385 t.unknown_ = unknownValueDeserialize(i) 386 } 387 return 388 389} 390 391// Serialize turns this object into an interface{}. 392func (t *nameIntermediateType) Serialize() (i interface{}, err error) { 393 if t.stringName != nil { 394 i = stringSerialize(*t.stringName) 395 return 396 } 397 if t.langString != nil { 398 i = langStringSerialize(*t.langString) 399 return 400 } 401 if t.IRI != nil { 402 i = IRISerialize(t.IRI) 403 return 404 } 405 i = unknownValueSerialize(t.unknown_) 406 return 407} 408 409// likedIntermediateType will only have one of its values set at most 410type likedIntermediateType struct { 411 // An unknown value. 412 unknown_ interface{} 413 // Stores possible CollectionType type for liked property 414 Collection CollectionType 415 // Stores possible OrderedCollectionType type for liked property 416 OrderedCollection OrderedCollectionType 417 // Stores possible *url.URL type for liked property 418 anyURI *url.URL 419} 420 421// Deserialize takes an interface{} and attempts to create a valid intermediate type. 422func (t *likedIntermediateType) Deserialize(i interface{}) (err error) { 423 matched := false 424 if m, ok := i.(map[string]interface{}); ok { 425 if tv, ok := m["type"]; ok { 426 var types []string 427 if tvs, ok := tv.([]interface{}); ok { 428 for _, tvi := range tvs { 429 if typeString, ok := tvi.(string); ok { 430 types = append(types, typeString) 431 } 432 } 433 } else if typeString, ok := tv.(string); ok { 434 types = append(types, typeString) 435 } 436 if !matched { 437 for _, kind := range types { 438 if t.Collection, ok = resolveObject(kind).(CollectionType); t.Collection != nil && ok { 439 err = t.Collection.Deserialize(m) 440 matched = true 441 break 442 } 443 } 444 } 445 if !matched { 446 for _, kind := range types { 447 if t.OrderedCollection, ok = resolveObject(kind).(OrderedCollectionType); t.OrderedCollection != nil && ok { 448 err = t.OrderedCollection.Deserialize(m) 449 matched = true 450 break 451 } 452 } 453 } 454 } else { 455 t.unknown_ = m 456 } 457 } else if i != nil { 458 if !matched { 459 t.anyURI, err = anyURIDeserialize(i) 460 if err != nil { 461 t.anyURI = nil 462 } else { 463 matched = true 464 } 465 } 466 } 467 if !matched { 468 t.unknown_ = unknownValueDeserialize(i) 469 } 470 return 471 472} 473 474// Serialize turns this object into an interface{}. 475func (t *likedIntermediateType) Serialize() (i interface{}, err error) { 476 if t.Collection != nil { 477 i, err = t.Collection.Serialize() 478 return 479 } 480 if t.OrderedCollection != nil { 481 i, err = t.OrderedCollection.Serialize() 482 return 483 } 484 if t.anyURI != nil { 485 i = anyURISerialize(t.anyURI) 486 return 487 } 488 i = unknownValueSerialize(t.unknown_) 489 return 490} 491 492// resultIntermediateType will only have one of its values set at most 493type resultIntermediateType struct { 494 // An unknown value. 495 unknown_ interface{} 496 // Stores possible ObjectType type for result property 497 Object ObjectType 498 // Stores possible LinkType type for result property 499 Link LinkType 500 // Stores possible *url.URL type for result property 501 IRI *url.URL 502} 503 504// Deserialize takes an interface{} and attempts to create a valid intermediate type. 505func (t *resultIntermediateType) Deserialize(i interface{}) (err error) { 506 matched := false 507 if m, ok := i.(map[string]interface{}); ok { 508 if tv, ok := m["type"]; ok { 509 var types []string 510 if tvs, ok := tv.([]interface{}); ok { 511 for _, tvi := range tvs { 512 if typeString, ok := tvi.(string); ok { 513 types = append(types, typeString) 514 } 515 } 516 } else if typeString, ok := tv.(string); ok { 517 types = append(types, typeString) 518 } 519 if !matched { 520 for _, kind := range types { 521 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 522 err = t.Object.Deserialize(m) 523 matched = true 524 break 525 } 526 } 527 } 528 if !matched { 529 for _, kind := range types { 530 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 531 err = t.Link.Deserialize(m) 532 matched = true 533 break 534 } 535 } 536 } 537 } else { 538 t.unknown_ = m 539 } 540 } else if i != nil { 541 if !matched { 542 t.IRI, err = IRIDeserialize(i) 543 if err != nil { 544 t.IRI = nil 545 } else { 546 matched = true 547 } 548 } 549 } 550 if !matched { 551 t.unknown_ = unknownValueDeserialize(i) 552 } 553 return 554 555} 556 557// Serialize turns this object into an interface{}. 558func (t *resultIntermediateType) Serialize() (i interface{}, err error) { 559 if t.Object != nil { 560 i, err = t.Object.Serialize() 561 return 562 } 563 if t.Link != nil { 564 i, err = t.Link.Serialize() 565 return 566 } 567 if t.IRI != nil { 568 i = IRISerialize(t.IRI) 569 return 570 } 571 i = unknownValueSerialize(t.unknown_) 572 return 573} 574 575// anyOfIntermediateType will only have one of its values set at most 576type anyOfIntermediateType struct { 577 // An unknown value. 578 unknown_ interface{} 579 // Stores possible ObjectType type for anyOf property 580 Object ObjectType 581 // Stores possible LinkType type for anyOf property 582 Link LinkType 583 // Stores possible *url.URL type for anyOf property 584 IRI *url.URL 585} 586 587// Deserialize takes an interface{} and attempts to create a valid intermediate type. 588func (t *anyOfIntermediateType) Deserialize(i interface{}) (err error) { 589 matched := false 590 if m, ok := i.(map[string]interface{}); ok { 591 if tv, ok := m["type"]; ok { 592 var types []string 593 if tvs, ok := tv.([]interface{}); ok { 594 for _, tvi := range tvs { 595 if typeString, ok := tvi.(string); ok { 596 types = append(types, typeString) 597 } 598 } 599 } else if typeString, ok := tv.(string); ok { 600 types = append(types, typeString) 601 } 602 if !matched { 603 for _, kind := range types { 604 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 605 err = t.Object.Deserialize(m) 606 matched = true 607 break 608 } 609 } 610 } 611 if !matched { 612 for _, kind := range types { 613 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 614 err = t.Link.Deserialize(m) 615 matched = true 616 break 617 } 618 } 619 } 620 } else { 621 t.unknown_ = m 622 } 623 } else if i != nil { 624 if !matched { 625 t.IRI, err = IRIDeserialize(i) 626 if err != nil { 627 t.IRI = nil 628 } else { 629 matched = true 630 } 631 } 632 } 633 if !matched { 634 t.unknown_ = unknownValueDeserialize(i) 635 } 636 return 637 638} 639 640// Serialize turns this object into an interface{}. 641func (t *anyOfIntermediateType) Serialize() (i interface{}, err error) { 642 if t.Object != nil { 643 i, err = t.Object.Serialize() 644 return 645 } 646 if t.Link != nil { 647 i, err = t.Link.Serialize() 648 return 649 } 650 if t.IRI != nil { 651 i = IRISerialize(t.IRI) 652 return 653 } 654 i = unknownValueSerialize(t.unknown_) 655 return 656} 657 658// generatorIntermediateType will only have one of its values set at most 659type generatorIntermediateType struct { 660 // An unknown value. 661 unknown_ interface{} 662 // Stores possible ObjectType type for generator property 663 Object ObjectType 664 // Stores possible LinkType type for generator property 665 Link LinkType 666 // Stores possible *url.URL type for generator property 667 IRI *url.URL 668} 669 670// Deserialize takes an interface{} and attempts to create a valid intermediate type. 671func (t *generatorIntermediateType) Deserialize(i interface{}) (err error) { 672 matched := false 673 if m, ok := i.(map[string]interface{}); ok { 674 if tv, ok := m["type"]; ok { 675 var types []string 676 if tvs, ok := tv.([]interface{}); ok { 677 for _, tvi := range tvs { 678 if typeString, ok := tvi.(string); ok { 679 types = append(types, typeString) 680 } 681 } 682 } else if typeString, ok := tv.(string); ok { 683 types = append(types, typeString) 684 } 685 if !matched { 686 for _, kind := range types { 687 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 688 err = t.Object.Deserialize(m) 689 matched = true 690 break 691 } 692 } 693 } 694 if !matched { 695 for _, kind := range types { 696 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 697 err = t.Link.Deserialize(m) 698 matched = true 699 break 700 } 701 } 702 } 703 } else { 704 t.unknown_ = m 705 } 706 } else if i != nil { 707 if !matched { 708 t.IRI, err = IRIDeserialize(i) 709 if err != nil { 710 t.IRI = nil 711 } else { 712 matched = true 713 } 714 } 715 } 716 if !matched { 717 t.unknown_ = unknownValueDeserialize(i) 718 } 719 return 720 721} 722 723// Serialize turns this object into an interface{}. 724func (t *generatorIntermediateType) Serialize() (i interface{}, err error) { 725 if t.Object != nil { 726 i, err = t.Object.Serialize() 727 return 728 } 729 if t.Link != nil { 730 i, err = t.Link.Serialize() 731 return 732 } 733 if t.IRI != nil { 734 i = IRISerialize(t.IRI) 735 return 736 } 737 i = unknownValueSerialize(t.unknown_) 738 return 739} 740 741// toIntermediateType will only have one of its values set at most 742type toIntermediateType struct { 743 // An unknown value. 744 unknown_ interface{} 745 // Stores possible ObjectType type for to property 746 Object ObjectType 747 // Stores possible LinkType type for to property 748 Link LinkType 749 // Stores possible *url.URL type for to property 750 IRI *url.URL 751} 752 753// Deserialize takes an interface{} and attempts to create a valid intermediate type. 754func (t *toIntermediateType) Deserialize(i interface{}) (err error) { 755 matched := false 756 if m, ok := i.(map[string]interface{}); ok { 757 if tv, ok := m["type"]; ok { 758 var types []string 759 if tvs, ok := tv.([]interface{}); ok { 760 for _, tvi := range tvs { 761 if typeString, ok := tvi.(string); ok { 762 types = append(types, typeString) 763 } 764 } 765 } else if typeString, ok := tv.(string); ok { 766 types = append(types, typeString) 767 } 768 if !matched { 769 for _, kind := range types { 770 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 771 err = t.Object.Deserialize(m) 772 matched = true 773 break 774 } 775 } 776 } 777 if !matched { 778 for _, kind := range types { 779 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 780 err = t.Link.Deserialize(m) 781 matched = true 782 break 783 } 784 } 785 } 786 } else { 787 t.unknown_ = m 788 } 789 } else if i != nil { 790 if !matched { 791 t.IRI, err = IRIDeserialize(i) 792 if err != nil { 793 t.IRI = nil 794 } else { 795 matched = true 796 } 797 } 798 } 799 if !matched { 800 t.unknown_ = unknownValueDeserialize(i) 801 } 802 return 803 804} 805 806// Serialize turns this object into an interface{}. 807func (t *toIntermediateType) Serialize() (i interface{}, err error) { 808 if t.Object != nil { 809 i, err = t.Object.Serialize() 810 return 811 } 812 if t.Link != nil { 813 i, err = t.Link.Serialize() 814 return 815 } 816 if t.IRI != nil { 817 i = IRISerialize(t.IRI) 818 return 819 } 820 i = unknownValueSerialize(t.unknown_) 821 return 822} 823 824// followersIntermediateType will only have one of its values set at most 825type followersIntermediateType struct { 826 // An unknown value. 827 unknown_ interface{} 828 // Stores possible CollectionType type for followers property 829 Collection CollectionType 830 // Stores possible OrderedCollectionType type for followers property 831 OrderedCollection OrderedCollectionType 832 // Stores possible *url.URL type for followers property 833 anyURI *url.URL 834} 835 836// Deserialize takes an interface{} and attempts to create a valid intermediate type. 837func (t *followersIntermediateType) Deserialize(i interface{}) (err error) { 838 matched := false 839 if m, ok := i.(map[string]interface{}); ok { 840 if tv, ok := m["type"]; ok { 841 var types []string 842 if tvs, ok := tv.([]interface{}); ok { 843 for _, tvi := range tvs { 844 if typeString, ok := tvi.(string); ok { 845 types = append(types, typeString) 846 } 847 } 848 } else if typeString, ok := tv.(string); ok { 849 types = append(types, typeString) 850 } 851 if !matched { 852 for _, kind := range types { 853 if t.Collection, ok = resolveObject(kind).(CollectionType); t.Collection != nil && ok { 854 err = t.Collection.Deserialize(m) 855 matched = true 856 break 857 } 858 } 859 } 860 if !matched { 861 for _, kind := range types { 862 if t.OrderedCollection, ok = resolveObject(kind).(OrderedCollectionType); t.OrderedCollection != nil && ok { 863 err = t.OrderedCollection.Deserialize(m) 864 matched = true 865 break 866 } 867 } 868 } 869 } else { 870 t.unknown_ = m 871 } 872 } else if i != nil { 873 if !matched { 874 t.anyURI, err = anyURIDeserialize(i) 875 if err != nil { 876 t.anyURI = nil 877 } else { 878 matched = true 879 } 880 } 881 } 882 if !matched { 883 t.unknown_ = unknownValueDeserialize(i) 884 } 885 return 886 887} 888 889// Serialize turns this object into an interface{}. 890func (t *followersIntermediateType) Serialize() (i interface{}, err error) { 891 if t.Collection != nil { 892 i, err = t.Collection.Serialize() 893 return 894 } 895 if t.OrderedCollection != nil { 896 i, err = t.OrderedCollection.Serialize() 897 return 898 } 899 if t.anyURI != nil { 900 i = anyURISerialize(t.anyURI) 901 return 902 } 903 i = unknownValueSerialize(t.unknown_) 904 return 905} 906 907// likesIntermediateType will only have one of its values set at most 908type likesIntermediateType struct { 909 // An unknown value. 910 unknown_ interface{} 911 // Stores possible CollectionType type for likes property 912 Collection CollectionType 913 // Stores possible OrderedCollectionType type for likes property 914 OrderedCollection OrderedCollectionType 915 // Stores possible *url.URL type for likes property 916 anyURI *url.URL 917} 918 919// Deserialize takes an interface{} and attempts to create a valid intermediate type. 920func (t *likesIntermediateType) Deserialize(i interface{}) (err error) { 921 matched := false 922 if m, ok := i.(map[string]interface{}); ok { 923 if tv, ok := m["type"]; ok { 924 var types []string 925 if tvs, ok := tv.([]interface{}); ok { 926 for _, tvi := range tvs { 927 if typeString, ok := tvi.(string); ok { 928 types = append(types, typeString) 929 } 930 } 931 } else if typeString, ok := tv.(string); ok { 932 types = append(types, typeString) 933 } 934 if !matched { 935 for _, kind := range types { 936 if t.Collection, ok = resolveObject(kind).(CollectionType); t.Collection != nil && ok { 937 err = t.Collection.Deserialize(m) 938 matched = true 939 break 940 } 941 } 942 } 943 if !matched { 944 for _, kind := range types { 945 if t.OrderedCollection, ok = resolveObject(kind).(OrderedCollectionType); t.OrderedCollection != nil && ok { 946 err = t.OrderedCollection.Deserialize(m) 947 matched = true 948 break 949 } 950 } 951 } 952 } else { 953 t.unknown_ = m 954 } 955 } else if i != nil { 956 if !matched { 957 t.anyURI, err = anyURIDeserialize(i) 958 if err != nil { 959 t.anyURI = nil 960 } else { 961 matched = true 962 } 963 } 964 } 965 if !matched { 966 t.unknown_ = unknownValueDeserialize(i) 967 } 968 return 969 970} 971 972// Serialize turns this object into an interface{}. 973func (t *likesIntermediateType) Serialize() (i interface{}, err error) { 974 if t.Collection != nil { 975 i, err = t.Collection.Serialize() 976 return 977 } 978 if t.OrderedCollection != nil { 979 i, err = t.OrderedCollection.Serialize() 980 return 981 } 982 if t.anyURI != nil { 983 i = anyURISerialize(t.anyURI) 984 return 985 } 986 i = unknownValueSerialize(t.unknown_) 987 return 988} 989 990// contentIntermediateType will only have one of its values set at most 991type contentIntermediateType struct { 992 // An unknown value. 993 unknown_ interface{} 994 // Stores possible *string type for content property 995 stringName *string 996 // Stores possible *string type for content property 997 langString *string 998 // Stores possible *url.URL type for content property 999 IRI *url.URL 1000} 1001 1002// Deserialize takes an interface{} and attempts to create a valid intermediate type. 1003func (t *contentIntermediateType) Deserialize(i interface{}) (err error) { 1004 matched := false 1005 if m, ok := i.(map[string]interface{}); ok { 1006 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 1007 } else if i != nil { 1008 if !matched { 1009 t.stringName, err = stringDeserialize(i) 1010 if err != nil { 1011 t.stringName = nil 1012 } else { 1013 matched = true 1014 } 1015 } 1016 if !matched { 1017 t.langString, err = langStringDeserialize(i) 1018 if err != nil { 1019 t.langString = nil 1020 } else { 1021 matched = true 1022 } 1023 } 1024 if !matched { 1025 t.IRI, err = IRIDeserialize(i) 1026 if err != nil { 1027 t.IRI = nil 1028 } else { 1029 matched = true 1030 } 1031 } 1032 } 1033 if !matched { 1034 t.unknown_ = unknownValueDeserialize(i) 1035 } 1036 return 1037 1038} 1039 1040// Serialize turns this object into an interface{}. 1041func (t *contentIntermediateType) Serialize() (i interface{}, err error) { 1042 if t.stringName != nil { 1043 i = stringSerialize(*t.stringName) 1044 return 1045 } 1046 if t.langString != nil { 1047 i = langStringSerialize(*t.langString) 1048 return 1049 } 1050 if t.IRI != nil { 1051 i = IRISerialize(t.IRI) 1052 return 1053 } 1054 i = unknownValueSerialize(t.unknown_) 1055 return 1056} 1057 1058// startTimeIntermediateType will only have one of its values set at most 1059type startTimeIntermediateType struct { 1060 // An unknown value. 1061 unknown_ interface{} 1062 // Stores possible *time.Time type for startTime property 1063 dateTime *time.Time 1064 // Stores possible *url.URL type for startTime property 1065 IRI *url.URL 1066} 1067 1068// Deserialize takes an interface{} and attempts to create a valid intermediate type. 1069func (t *startTimeIntermediateType) Deserialize(i interface{}) (err error) { 1070 matched := false 1071 if m, ok := i.(map[string]interface{}); ok { 1072 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 1073 } else if i != nil { 1074 if !matched { 1075 t.dateTime, err = dateTimeDeserialize(i) 1076 if err != nil { 1077 t.dateTime = nil 1078 } else { 1079 matched = true 1080 } 1081 } 1082 if !matched { 1083 t.IRI, err = IRIDeserialize(i) 1084 if err != nil { 1085 t.IRI = nil 1086 } else { 1087 matched = true 1088 } 1089 } 1090 } 1091 if !matched { 1092 t.unknown_ = unknownValueDeserialize(i) 1093 } 1094 return 1095 1096} 1097 1098// Serialize turns this object into an interface{}. 1099func (t *startTimeIntermediateType) Serialize() (i interface{}, err error) { 1100 if t.dateTime != nil { 1101 i = dateTimeSerialize(*t.dateTime) 1102 return 1103 } 1104 if t.IRI != nil { 1105 i = IRISerialize(t.IRI) 1106 return 1107 } 1108 i = unknownValueSerialize(t.unknown_) 1109 return 1110} 1111 1112// inboxIntermediateType will only have one of its values set at most 1113type inboxIntermediateType struct { 1114 // An unknown value. 1115 unknown_ interface{} 1116 // Stores possible OrderedCollectionType type for inbox property 1117 OrderedCollection OrderedCollectionType 1118 // Stores possible *url.URL type for inbox property 1119 anyURI *url.URL 1120} 1121 1122// Deserialize takes an interface{} and attempts to create a valid intermediate type. 1123func (t *inboxIntermediateType) Deserialize(i interface{}) (err error) { 1124 matched := false 1125 if m, ok := i.(map[string]interface{}); ok { 1126 if tv, ok := m["type"]; ok { 1127 var types []string 1128 if tvs, ok := tv.([]interface{}); ok { 1129 for _, tvi := range tvs { 1130 if typeString, ok := tvi.(string); ok { 1131 types = append(types, typeString) 1132 } 1133 } 1134 } else if typeString, ok := tv.(string); ok { 1135 types = append(types, typeString) 1136 } 1137 if !matched { 1138 for _, kind := range types { 1139 if t.OrderedCollection, ok = resolveObject(kind).(OrderedCollectionType); t.OrderedCollection != nil && ok { 1140 err = t.OrderedCollection.Deserialize(m) 1141 matched = true 1142 break 1143 } 1144 } 1145 } 1146 } else { 1147 t.unknown_ = m 1148 } 1149 } else if i != nil { 1150 if !matched { 1151 t.anyURI, err = anyURIDeserialize(i) 1152 if err != nil { 1153 t.anyURI = nil 1154 } else { 1155 matched = true 1156 } 1157 } 1158 } 1159 if !matched { 1160 t.unknown_ = unknownValueDeserialize(i) 1161 } 1162 return 1163 1164} 1165 1166// Serialize turns this object into an interface{}. 1167func (t *inboxIntermediateType) Serialize() (i interface{}, err error) { 1168 if t.OrderedCollection != nil { 1169 i, err = t.OrderedCollection.Serialize() 1170 return 1171 } 1172 if t.anyURI != nil { 1173 i = anyURISerialize(t.anyURI) 1174 return 1175 } 1176 i = unknownValueSerialize(t.unknown_) 1177 return 1178} 1179 1180// previewIntermediateType will only have one of its values set at most 1181type previewIntermediateType struct { 1182 // An unknown value. 1183 unknown_ interface{} 1184 // Stores possible ObjectType type for preview property 1185 Object ObjectType 1186 // Stores possible LinkType type for preview property 1187 Link LinkType 1188 // Stores possible *url.URL type for preview property 1189 IRI *url.URL 1190} 1191 1192// Deserialize takes an interface{} and attempts to create a valid intermediate type. 1193func (t *previewIntermediateType) Deserialize(i interface{}) (err error) { 1194 matched := false 1195 if m, ok := i.(map[string]interface{}); ok { 1196 if tv, ok := m["type"]; ok { 1197 var types []string 1198 if tvs, ok := tv.([]interface{}); ok { 1199 for _, tvi := range tvs { 1200 if typeString, ok := tvi.(string); ok { 1201 types = append(types, typeString) 1202 } 1203 } 1204 } else if typeString, ok := tv.(string); ok { 1205 types = append(types, typeString) 1206 } 1207 if !matched { 1208 for _, kind := range types { 1209 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 1210 err = t.Object.Deserialize(m) 1211 matched = true 1212 break 1213 } 1214 } 1215 } 1216 if !matched { 1217 for _, kind := range types { 1218 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 1219 err = t.Link.Deserialize(m) 1220 matched = true 1221 break 1222 } 1223 } 1224 } 1225 } else { 1226 t.unknown_ = m 1227 } 1228 } else if i != nil { 1229 if !matched { 1230 t.IRI, err = IRIDeserialize(i) 1231 if err != nil { 1232 t.IRI = nil 1233 } else { 1234 matched = true 1235 } 1236 } 1237 } 1238 if !matched { 1239 t.unknown_ = unknownValueDeserialize(i) 1240 } 1241 return 1242 1243} 1244 1245// Serialize turns this object into an interface{}. 1246func (t *previewIntermediateType) Serialize() (i interface{}, err error) { 1247 if t.Object != nil { 1248 i, err = t.Object.Serialize() 1249 return 1250 } 1251 if t.Link != nil { 1252 i, err = t.Link.Serialize() 1253 return 1254 } 1255 if t.IRI != nil { 1256 i = IRISerialize(t.IRI) 1257 return 1258 } 1259 i = unknownValueSerialize(t.unknown_) 1260 return 1261} 1262 1263// hreflangIntermediateType will only have one of its values set at most 1264type hreflangIntermediateType struct { 1265 // An unknown value. 1266 unknown_ interface{} 1267 // Stores possible *string type for hreflang property 1268 bcp47LanguageTag *string 1269 // Stores possible *url.URL type for hreflang property 1270 IRI *url.URL 1271} 1272 1273// Deserialize takes an interface{} and attempts to create a valid intermediate type. 1274func (t *hreflangIntermediateType) Deserialize(i interface{}) (err error) { 1275 matched := false 1276 if m, ok := i.(map[string]interface{}); ok { 1277 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 1278 } else if i != nil { 1279 if !matched { 1280 t.bcp47LanguageTag, err = bcp47LanguageTagDeserialize(i) 1281 if err != nil { 1282 t.bcp47LanguageTag = nil 1283 } else { 1284 matched = true 1285 } 1286 } 1287 if !matched { 1288 t.IRI, err = IRIDeserialize(i) 1289 if err != nil { 1290 t.IRI = nil 1291 } else { 1292 matched = true 1293 } 1294 } 1295 } 1296 if !matched { 1297 t.unknown_ = unknownValueDeserialize(i) 1298 } 1299 return 1300 1301} 1302 1303// Serialize turns this object into an interface{}. 1304func (t *hreflangIntermediateType) Serialize() (i interface{}, err error) { 1305 if t.bcp47LanguageTag != nil { 1306 i = bcp47LanguageTagSerialize(*t.bcp47LanguageTag) 1307 return 1308 } 1309 if t.IRI != nil { 1310 i = IRISerialize(t.IRI) 1311 return 1312 } 1313 i = unknownValueSerialize(t.unknown_) 1314 return 1315} 1316 1317// latitudeIntermediateType will only have one of its values set at most 1318type latitudeIntermediateType struct { 1319 // An unknown value. 1320 unknown_ interface{} 1321 // Stores possible *float64 type for latitude property 1322 float *float64 1323 // Stores possible *url.URL type for latitude property 1324 IRI *url.URL 1325} 1326 1327// Deserialize takes an interface{} and attempts to create a valid intermediate type. 1328func (t *latitudeIntermediateType) Deserialize(i interface{}) (err error) { 1329 matched := false 1330 if m, ok := i.(map[string]interface{}); ok { 1331 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 1332 } else if i != nil { 1333 if !matched { 1334 t.float, err = floatDeserialize(i) 1335 if err != nil { 1336 t.float = nil 1337 } else { 1338 matched = true 1339 } 1340 } 1341 if !matched { 1342 t.IRI, err = IRIDeserialize(i) 1343 if err != nil { 1344 t.IRI = nil 1345 } else { 1346 matched = true 1347 } 1348 } 1349 } 1350 if !matched { 1351 t.unknown_ = unknownValueDeserialize(i) 1352 } 1353 return 1354 1355} 1356 1357// Serialize turns this object into an interface{}. 1358func (t *latitudeIntermediateType) Serialize() (i interface{}, err error) { 1359 if t.float != nil { 1360 i = floatSerialize(*t.float) 1361 return 1362 } 1363 if t.IRI != nil { 1364 i = IRISerialize(t.IRI) 1365 return 1366 } 1367 i = unknownValueSerialize(t.unknown_) 1368 return 1369} 1370 1371// describesIntermediateType will only have one of its values set at most 1372type describesIntermediateType struct { 1373 // An unknown value. 1374 unknown_ interface{} 1375 // Stores possible ObjectType type for describes property 1376 Object ObjectType 1377 // Stores possible *url.URL type for describes property 1378 IRI *url.URL 1379} 1380 1381// Deserialize takes an interface{} and attempts to create a valid intermediate type. 1382func (t *describesIntermediateType) Deserialize(i interface{}) (err error) { 1383 matched := false 1384 if m, ok := i.(map[string]interface{}); ok { 1385 if tv, ok := m["type"]; ok { 1386 var types []string 1387 if tvs, ok := tv.([]interface{}); ok { 1388 for _, tvi := range tvs { 1389 if typeString, ok := tvi.(string); ok { 1390 types = append(types, typeString) 1391 } 1392 } 1393 } else if typeString, ok := tv.(string); ok { 1394 types = append(types, typeString) 1395 } 1396 if !matched { 1397 for _, kind := range types { 1398 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 1399 err = t.Object.Deserialize(m) 1400 matched = true 1401 break 1402 } 1403 } 1404 } 1405 } else { 1406 t.unknown_ = m 1407 } 1408 } else if i != nil { 1409 if !matched { 1410 t.IRI, err = IRIDeserialize(i) 1411 if err != nil { 1412 t.IRI = nil 1413 } else { 1414 matched = true 1415 } 1416 } 1417 } 1418 if !matched { 1419 t.unknown_ = unknownValueDeserialize(i) 1420 } 1421 return 1422 1423} 1424 1425// Serialize turns this object into an interface{}. 1426func (t *describesIntermediateType) Serialize() (i interface{}, err error) { 1427 if t.Object != nil { 1428 i, err = t.Object.Serialize() 1429 return 1430 } 1431 if t.IRI != nil { 1432 i = IRISerialize(t.IRI) 1433 return 1434 } 1435 i = unknownValueSerialize(t.unknown_) 1436 return 1437} 1438 1439// locationIntermediateType will only have one of its values set at most 1440type locationIntermediateType struct { 1441 // An unknown value. 1442 unknown_ interface{} 1443 // Stores possible ObjectType type for location property 1444 Object ObjectType 1445 // Stores possible LinkType type for location property 1446 Link LinkType 1447 // Stores possible *url.URL type for location property 1448 IRI *url.URL 1449} 1450 1451// Deserialize takes an interface{} and attempts to create a valid intermediate type. 1452func (t *locationIntermediateType) Deserialize(i interface{}) (err error) { 1453 matched := false 1454 if m, ok := i.(map[string]interface{}); ok { 1455 if tv, ok := m["type"]; ok { 1456 var types []string 1457 if tvs, ok := tv.([]interface{}); ok { 1458 for _, tvi := range tvs { 1459 if typeString, ok := tvi.(string); ok { 1460 types = append(types, typeString) 1461 } 1462 } 1463 } else if typeString, ok := tv.(string); ok { 1464 types = append(types, typeString) 1465 } 1466 if !matched { 1467 for _, kind := range types { 1468 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 1469 err = t.Object.Deserialize(m) 1470 matched = true 1471 break 1472 } 1473 } 1474 } 1475 if !matched { 1476 for _, kind := range types { 1477 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 1478 err = t.Link.Deserialize(m) 1479 matched = true 1480 break 1481 } 1482 } 1483 } 1484 } else { 1485 t.unknown_ = m 1486 } 1487 } else if i != nil { 1488 if !matched { 1489 t.IRI, err = IRIDeserialize(i) 1490 if err != nil { 1491 t.IRI = nil 1492 } else { 1493 matched = true 1494 } 1495 } 1496 } 1497 if !matched { 1498 t.unknown_ = unknownValueDeserialize(i) 1499 } 1500 return 1501 1502} 1503 1504// Serialize turns this object into an interface{}. 1505func (t *locationIntermediateType) Serialize() (i interface{}, err error) { 1506 if t.Object != nil { 1507 i, err = t.Object.Serialize() 1508 return 1509 } 1510 if t.Link != nil { 1511 i, err = t.Link.Serialize() 1512 return 1513 } 1514 if t.IRI != nil { 1515 i = IRISerialize(t.IRI) 1516 return 1517 } 1518 i = unknownValueSerialize(t.unknown_) 1519 return 1520} 1521 1522// tagIntermediateType will only have one of its values set at most 1523type tagIntermediateType struct { 1524 // An unknown value. 1525 unknown_ interface{} 1526 // Stores possible ObjectType type for tag property 1527 Object ObjectType 1528 // Stores possible LinkType type for tag property 1529 Link LinkType 1530 // Stores possible *url.URL type for tag property 1531 IRI *url.URL 1532} 1533 1534// Deserialize takes an interface{} and attempts to create a valid intermediate type. 1535func (t *tagIntermediateType) Deserialize(i interface{}) (err error) { 1536 matched := false 1537 if m, ok := i.(map[string]interface{}); ok { 1538 if tv, ok := m["type"]; ok { 1539 var types []string 1540 if tvs, ok := tv.([]interface{}); ok { 1541 for _, tvi := range tvs { 1542 if typeString, ok := tvi.(string); ok { 1543 types = append(types, typeString) 1544 } 1545 } 1546 } else if typeString, ok := tv.(string); ok { 1547 types = append(types, typeString) 1548 } 1549 if !matched { 1550 for _, kind := range types { 1551 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 1552 err = t.Object.Deserialize(m) 1553 matched = true 1554 break 1555 } 1556 } 1557 } 1558 if !matched { 1559 for _, kind := range types { 1560 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 1561 err = t.Link.Deserialize(m) 1562 matched = true 1563 break 1564 } 1565 } 1566 } 1567 } else { 1568 t.unknown_ = m 1569 } 1570 } else if i != nil { 1571 if !matched { 1572 t.IRI, err = IRIDeserialize(i) 1573 if err != nil { 1574 t.IRI = nil 1575 } else { 1576 matched = true 1577 } 1578 } 1579 } 1580 if !matched { 1581 t.unknown_ = unknownValueDeserialize(i) 1582 } 1583 return 1584 1585} 1586 1587// Serialize turns this object into an interface{}. 1588func (t *tagIntermediateType) Serialize() (i interface{}, err error) { 1589 if t.Object != nil { 1590 i, err = t.Object.Serialize() 1591 return 1592 } 1593 if t.Link != nil { 1594 i, err = t.Link.Serialize() 1595 return 1596 } 1597 if t.IRI != nil { 1598 i = IRISerialize(t.IRI) 1599 return 1600 } 1601 i = unknownValueSerialize(t.unknown_) 1602 return 1603} 1604 1605// sourceIntermediateType will only have one of its values set at most 1606type sourceIntermediateType struct { 1607 // An unknown value. 1608 unknown_ interface{} 1609 // Stores possible ObjectType type for source property 1610 Object ObjectType 1611 // Stores possible *url.URL type for source property 1612 IRI *url.URL 1613} 1614 1615// Deserialize takes an interface{} and attempts to create a valid intermediate type. 1616func (t *sourceIntermediateType) Deserialize(i interface{}) (err error) { 1617 matched := false 1618 if m, ok := i.(map[string]interface{}); ok { 1619 if tv, ok := m["type"]; ok { 1620 var types []string 1621 if tvs, ok := tv.([]interface{}); ok { 1622 for _, tvi := range tvs { 1623 if typeString, ok := tvi.(string); ok { 1624 types = append(types, typeString) 1625 } 1626 } 1627 } else if typeString, ok := tv.(string); ok { 1628 types = append(types, typeString) 1629 } 1630 if !matched { 1631 for _, kind := range types { 1632 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 1633 err = t.Object.Deserialize(m) 1634 matched = true 1635 break 1636 } 1637 } 1638 } 1639 } else { 1640 t.unknown_ = m 1641 } 1642 } else if i != nil { 1643 if !matched { 1644 t.IRI, err = IRIDeserialize(i) 1645 if err != nil { 1646 t.IRI = nil 1647 } else { 1648 matched = true 1649 } 1650 } 1651 } 1652 if !matched { 1653 t.unknown_ = unknownValueDeserialize(i) 1654 } 1655 return 1656 1657} 1658 1659// Serialize turns this object into an interface{}. 1660func (t *sourceIntermediateType) Serialize() (i interface{}, err error) { 1661 if t.Object != nil { 1662 i, err = t.Object.Serialize() 1663 return 1664 } 1665 if t.IRI != nil { 1666 i = IRISerialize(t.IRI) 1667 return 1668 } 1669 i = unknownValueSerialize(t.unknown_) 1670 return 1671} 1672 1673// subjectIntermediateType will only have one of its values set at most 1674type subjectIntermediateType struct { 1675 // An unknown value. 1676 unknown_ interface{} 1677 // Stores possible ObjectType type for subject property 1678 Object ObjectType 1679 // Stores possible LinkType type for subject property 1680 Link LinkType 1681 // Stores possible *url.URL type for subject property 1682 IRI *url.URL 1683} 1684 1685// Deserialize takes an interface{} and attempts to create a valid intermediate type. 1686func (t *subjectIntermediateType) Deserialize(i interface{}) (err error) { 1687 matched := false 1688 if m, ok := i.(map[string]interface{}); ok { 1689 if tv, ok := m["type"]; ok { 1690 var types []string 1691 if tvs, ok := tv.([]interface{}); ok { 1692 for _, tvi := range tvs { 1693 if typeString, ok := tvi.(string); ok { 1694 types = append(types, typeString) 1695 } 1696 } 1697 } else if typeString, ok := tv.(string); ok { 1698 types = append(types, typeString) 1699 } 1700 if !matched { 1701 for _, kind := range types { 1702 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 1703 err = t.Object.Deserialize(m) 1704 matched = true 1705 break 1706 } 1707 } 1708 } 1709 if !matched { 1710 for _, kind := range types { 1711 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 1712 err = t.Link.Deserialize(m) 1713 matched = true 1714 break 1715 } 1716 } 1717 } 1718 } else { 1719 t.unknown_ = m 1720 } 1721 } else if i != nil { 1722 if !matched { 1723 t.IRI, err = IRIDeserialize(i) 1724 if err != nil { 1725 t.IRI = nil 1726 } else { 1727 matched = true 1728 } 1729 } 1730 } 1731 if !matched { 1732 t.unknown_ = unknownValueDeserialize(i) 1733 } 1734 return 1735 1736} 1737 1738// Serialize turns this object into an interface{}. 1739func (t *subjectIntermediateType) Serialize() (i interface{}, err error) { 1740 if t.Object != nil { 1741 i, err = t.Object.Serialize() 1742 return 1743 } 1744 if t.Link != nil { 1745 i, err = t.Link.Serialize() 1746 return 1747 } 1748 if t.IRI != nil { 1749 i = IRISerialize(t.IRI) 1750 return 1751 } 1752 i = unknownValueSerialize(t.unknown_) 1753 return 1754} 1755 1756// preferredUsernameIntermediateType will only have one of its values set at most 1757type preferredUsernameIntermediateType struct { 1758 // An unknown value. 1759 unknown_ interface{} 1760 // Stores possible *string type for preferredUsername property 1761 stringName *string 1762 // Stores possible *url.URL type for preferredUsername property 1763 IRI *url.URL 1764} 1765 1766// Deserialize takes an interface{} and attempts to create a valid intermediate type. 1767func (t *preferredUsernameIntermediateType) Deserialize(i interface{}) (err error) { 1768 matched := false 1769 if m, ok := i.(map[string]interface{}); ok { 1770 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 1771 } else if i != nil { 1772 if !matched { 1773 t.stringName, err = stringDeserialize(i) 1774 if err != nil { 1775 t.stringName = nil 1776 } else { 1777 matched = true 1778 } 1779 } 1780 if !matched { 1781 t.IRI, err = IRIDeserialize(i) 1782 if err != nil { 1783 t.IRI = nil 1784 } else { 1785 matched = true 1786 } 1787 } 1788 } 1789 if !matched { 1790 t.unknown_ = unknownValueDeserialize(i) 1791 } 1792 return 1793 1794} 1795 1796// Serialize turns this object into an interface{}. 1797func (t *preferredUsernameIntermediateType) Serialize() (i interface{}, err error) { 1798 if t.stringName != nil { 1799 i = stringSerialize(*t.stringName) 1800 return 1801 } 1802 if t.IRI != nil { 1803 i = IRISerialize(t.IRI) 1804 return 1805 } 1806 i = unknownValueSerialize(t.unknown_) 1807 return 1808} 1809 1810// unitsIntermediateType will only have one of its values set at most 1811type unitsIntermediateType struct { 1812 // An unknown value. 1813 unknown_ interface{} 1814 // Stores possible *string type for units property 1815 unitsValue *string 1816 // Stores possible *url.URL type for units property 1817 anyURI *url.URL 1818} 1819 1820// Deserialize takes an interface{} and attempts to create a valid intermediate type. 1821func (t *unitsIntermediateType) Deserialize(i interface{}) (err error) { 1822 matched := false 1823 if m, ok := i.(map[string]interface{}); ok { 1824 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 1825 } else if i != nil { 1826 if !matched { 1827 t.unitsValue, err = unitsValueDeserialize(i) 1828 if err != nil { 1829 t.unitsValue = nil 1830 } else { 1831 matched = true 1832 } 1833 } 1834 if !matched { 1835 t.anyURI, err = anyURIDeserialize(i) 1836 if err != nil { 1837 t.anyURI = nil 1838 } else { 1839 matched = true 1840 } 1841 } 1842 } 1843 if !matched { 1844 t.unknown_ = unknownValueDeserialize(i) 1845 } 1846 return 1847 1848} 1849 1850// Serialize turns this object into an interface{}. 1851func (t *unitsIntermediateType) Serialize() (i interface{}, err error) { 1852 if t.unitsValue != nil { 1853 i = unitsValueSerialize(*t.unitsValue) 1854 return 1855 } 1856 if t.anyURI != nil { 1857 i = anyURISerialize(t.anyURI) 1858 return 1859 } 1860 i = unknownValueSerialize(t.unknown_) 1861 return 1862} 1863 1864// altitudeIntermediateType will only have one of its values set at most 1865type altitudeIntermediateType struct { 1866 // An unknown value. 1867 unknown_ interface{} 1868 // Stores possible *float64 type for altitude property 1869 float *float64 1870 // Stores possible *url.URL type for altitude property 1871 IRI *url.URL 1872} 1873 1874// Deserialize takes an interface{} and attempts to create a valid intermediate type. 1875func (t *altitudeIntermediateType) Deserialize(i interface{}) (err error) { 1876 matched := false 1877 if m, ok := i.(map[string]interface{}); ok { 1878 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 1879 } else if i != nil { 1880 if !matched { 1881 t.float, err = floatDeserialize(i) 1882 if err != nil { 1883 t.float = nil 1884 } else { 1885 matched = true 1886 } 1887 } 1888 if !matched { 1889 t.IRI, err = IRIDeserialize(i) 1890 if err != nil { 1891 t.IRI = nil 1892 } else { 1893 matched = true 1894 } 1895 } 1896 } 1897 if !matched { 1898 t.unknown_ = unknownValueDeserialize(i) 1899 } 1900 return 1901 1902} 1903 1904// Serialize turns this object into an interface{}. 1905func (t *altitudeIntermediateType) Serialize() (i interface{}, err error) { 1906 if t.float != nil { 1907 i = floatSerialize(*t.float) 1908 return 1909 } 1910 if t.IRI != nil { 1911 i = IRISerialize(t.IRI) 1912 return 1913 } 1914 i = unknownValueSerialize(t.unknown_) 1915 return 1916} 1917 1918// attachmentIntermediateType will only have one of its values set at most 1919type attachmentIntermediateType struct { 1920 // An unknown value. 1921 unknown_ interface{} 1922 // Stores possible ObjectType type for attachment property 1923 Object ObjectType 1924 // Stores possible LinkType type for attachment property 1925 Link LinkType 1926 // Stores possible *url.URL type for attachment property 1927 IRI *url.URL 1928} 1929 1930// Deserialize takes an interface{} and attempts to create a valid intermediate type. 1931func (t *attachmentIntermediateType) Deserialize(i interface{}) (err error) { 1932 matched := false 1933 if m, ok := i.(map[string]interface{}); ok { 1934 if tv, ok := m["type"]; ok { 1935 var types []string 1936 if tvs, ok := tv.([]interface{}); ok { 1937 for _, tvi := range tvs { 1938 if typeString, ok := tvi.(string); ok { 1939 types = append(types, typeString) 1940 } 1941 } 1942 } else if typeString, ok := tv.(string); ok { 1943 types = append(types, typeString) 1944 } 1945 if !matched { 1946 for _, kind := range types { 1947 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 1948 err = t.Object.Deserialize(m) 1949 matched = true 1950 break 1951 } 1952 } 1953 } 1954 if !matched { 1955 for _, kind := range types { 1956 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 1957 err = t.Link.Deserialize(m) 1958 matched = true 1959 break 1960 } 1961 } 1962 } 1963 } else { 1964 t.unknown_ = m 1965 } 1966 } else if i != nil { 1967 if !matched { 1968 t.IRI, err = IRIDeserialize(i) 1969 if err != nil { 1970 t.IRI = nil 1971 } else { 1972 matched = true 1973 } 1974 } 1975 } 1976 if !matched { 1977 t.unknown_ = unknownValueDeserialize(i) 1978 } 1979 return 1980 1981} 1982 1983// Serialize turns this object into an interface{}. 1984func (t *attachmentIntermediateType) Serialize() (i interface{}, err error) { 1985 if t.Object != nil { 1986 i, err = t.Object.Serialize() 1987 return 1988 } 1989 if t.Link != nil { 1990 i, err = t.Link.Serialize() 1991 return 1992 } 1993 if t.IRI != nil { 1994 i = IRISerialize(t.IRI) 1995 return 1996 } 1997 i = unknownValueSerialize(t.unknown_) 1998 return 1999} 2000 2001// contextIntermediateType will only have one of its values set at most 2002type contextIntermediateType struct { 2003 // An unknown value. 2004 unknown_ interface{} 2005 // Stores possible ObjectType type for context property 2006 Object ObjectType 2007 // Stores possible LinkType type for context property 2008 Link LinkType 2009 // Stores possible *url.URL type for context property 2010 IRI *url.URL 2011} 2012 2013// Deserialize takes an interface{} and attempts to create a valid intermediate type. 2014func (t *contextIntermediateType) Deserialize(i interface{}) (err error) { 2015 matched := false 2016 if m, ok := i.(map[string]interface{}); ok { 2017 if tv, ok := m["type"]; ok { 2018 var types []string 2019 if tvs, ok := tv.([]interface{}); ok { 2020 for _, tvi := range tvs { 2021 if typeString, ok := tvi.(string); ok { 2022 types = append(types, typeString) 2023 } 2024 } 2025 } else if typeString, ok := tv.(string); ok { 2026 types = append(types, typeString) 2027 } 2028 if !matched { 2029 for _, kind := range types { 2030 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 2031 err = t.Object.Deserialize(m) 2032 matched = true 2033 break 2034 } 2035 } 2036 } 2037 if !matched { 2038 for _, kind := range types { 2039 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 2040 err = t.Link.Deserialize(m) 2041 matched = true 2042 break 2043 } 2044 } 2045 } 2046 } else { 2047 t.unknown_ = m 2048 } 2049 } else if i != nil { 2050 if !matched { 2051 t.IRI, err = IRIDeserialize(i) 2052 if err != nil { 2053 t.IRI = nil 2054 } else { 2055 matched = true 2056 } 2057 } 2058 } 2059 if !matched { 2060 t.unknown_ = unknownValueDeserialize(i) 2061 } 2062 return 2063 2064} 2065 2066// Serialize turns this object into an interface{}. 2067func (t *contextIntermediateType) Serialize() (i interface{}, err error) { 2068 if t.Object != nil { 2069 i, err = t.Object.Serialize() 2070 return 2071 } 2072 if t.Link != nil { 2073 i, err = t.Link.Serialize() 2074 return 2075 } 2076 if t.IRI != nil { 2077 i = IRISerialize(t.IRI) 2078 return 2079 } 2080 i = unknownValueSerialize(t.unknown_) 2081 return 2082} 2083 2084// repliesIntermediateType will only have one of its values set at most 2085type repliesIntermediateType struct { 2086 // An unknown value. 2087 unknown_ interface{} 2088 // Stores possible CollectionType type for replies property 2089 Collection CollectionType 2090 // Stores possible *url.URL type for replies property 2091 IRI *url.URL 2092} 2093 2094// Deserialize takes an interface{} and attempts to create a valid intermediate type. 2095func (t *repliesIntermediateType) Deserialize(i interface{}) (err error) { 2096 matched := false 2097 if m, ok := i.(map[string]interface{}); ok { 2098 if tv, ok := m["type"]; ok { 2099 var types []string 2100 if tvs, ok := tv.([]interface{}); ok { 2101 for _, tvi := range tvs { 2102 if typeString, ok := tvi.(string); ok { 2103 types = append(types, typeString) 2104 } 2105 } 2106 } else if typeString, ok := tv.(string); ok { 2107 types = append(types, typeString) 2108 } 2109 if !matched { 2110 for _, kind := range types { 2111 if t.Collection, ok = resolveObject(kind).(CollectionType); t.Collection != nil && ok { 2112 err = t.Collection.Deserialize(m) 2113 matched = true 2114 break 2115 } 2116 } 2117 } 2118 } else { 2119 t.unknown_ = m 2120 } 2121 } else if i != nil { 2122 if !matched { 2123 t.IRI, err = IRIDeserialize(i) 2124 if err != nil { 2125 t.IRI = nil 2126 } else { 2127 matched = true 2128 } 2129 } 2130 } 2131 if !matched { 2132 t.unknown_ = unknownValueDeserialize(i) 2133 } 2134 return 2135 2136} 2137 2138// Serialize turns this object into an interface{}. 2139func (t *repliesIntermediateType) Serialize() (i interface{}, err error) { 2140 if t.Collection != nil { 2141 i, err = t.Collection.Serialize() 2142 return 2143 } 2144 if t.IRI != nil { 2145 i = IRISerialize(t.IRI) 2146 return 2147 } 2148 i = unknownValueSerialize(t.unknown_) 2149 return 2150} 2151 2152// outboxIntermediateType will only have one of its values set at most 2153type outboxIntermediateType struct { 2154 // An unknown value. 2155 unknown_ interface{} 2156 // Stores possible OrderedCollectionType type for outbox property 2157 OrderedCollection OrderedCollectionType 2158 // Stores possible *url.URL type for outbox property 2159 anyURI *url.URL 2160} 2161 2162// Deserialize takes an interface{} and attempts to create a valid intermediate type. 2163func (t *outboxIntermediateType) Deserialize(i interface{}) (err error) { 2164 matched := false 2165 if m, ok := i.(map[string]interface{}); ok { 2166 if tv, ok := m["type"]; ok { 2167 var types []string 2168 if tvs, ok := tv.([]interface{}); ok { 2169 for _, tvi := range tvs { 2170 if typeString, ok := tvi.(string); ok { 2171 types = append(types, typeString) 2172 } 2173 } 2174 } else if typeString, ok := tv.(string); ok { 2175 types = append(types, typeString) 2176 } 2177 if !matched { 2178 for _, kind := range types { 2179 if t.OrderedCollection, ok = resolveObject(kind).(OrderedCollectionType); t.OrderedCollection != nil && ok { 2180 err = t.OrderedCollection.Deserialize(m) 2181 matched = true 2182 break 2183 } 2184 } 2185 } 2186 } else { 2187 t.unknown_ = m 2188 } 2189 } else if i != nil { 2190 if !matched { 2191 t.anyURI, err = anyURIDeserialize(i) 2192 if err != nil { 2193 t.anyURI = nil 2194 } else { 2195 matched = true 2196 } 2197 } 2198 } 2199 if !matched { 2200 t.unknown_ = unknownValueDeserialize(i) 2201 } 2202 return 2203 2204} 2205 2206// Serialize turns this object into an interface{}. 2207func (t *outboxIntermediateType) Serialize() (i interface{}, err error) { 2208 if t.OrderedCollection != nil { 2209 i, err = t.OrderedCollection.Serialize() 2210 return 2211 } 2212 if t.anyURI != nil { 2213 i = anyURISerialize(t.anyURI) 2214 return 2215 } 2216 i = unknownValueSerialize(t.unknown_) 2217 return 2218} 2219 2220// firstIntermediateType will only have one of its values set at most 2221type firstIntermediateType struct { 2222 // An unknown value. 2223 unknown_ interface{} 2224 // Stores possible CollectionPageType type for first property 2225 CollectionPage CollectionPageType 2226 // Stores possible LinkType type for first property 2227 Link LinkType 2228 // Stores possible *url.URL type for first property 2229 IRI *url.URL 2230 // Stores possible OrderedCollectionPageType type for first property 2231 OrderedCollectionPage OrderedCollectionPageType 2232} 2233 2234// Deserialize takes an interface{} and attempts to create a valid intermediate type. 2235func (t *firstIntermediateType) Deserialize(i interface{}) (err error) { 2236 matched := false 2237 if m, ok := i.(map[string]interface{}); ok { 2238 if tv, ok := m["type"]; ok { 2239 var types []string 2240 if tvs, ok := tv.([]interface{}); ok { 2241 for _, tvi := range tvs { 2242 if typeString, ok := tvi.(string); ok { 2243 types = append(types, typeString) 2244 } 2245 } 2246 } else if typeString, ok := tv.(string); ok { 2247 types = append(types, typeString) 2248 } 2249 if !matched { 2250 for _, kind := range types { 2251 if t.CollectionPage, ok = resolveObject(kind).(CollectionPageType); t.CollectionPage != nil && ok { 2252 err = t.CollectionPage.Deserialize(m) 2253 matched = true 2254 break 2255 } 2256 } 2257 } 2258 if !matched { 2259 for _, kind := range types { 2260 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 2261 err = t.Link.Deserialize(m) 2262 matched = true 2263 break 2264 } 2265 } 2266 } 2267 if !matched { 2268 for _, kind := range types { 2269 if t.OrderedCollectionPage, ok = resolveObject(kind).(OrderedCollectionPageType); t.OrderedCollectionPage != nil && ok { 2270 err = t.OrderedCollectionPage.Deserialize(m) 2271 matched = true 2272 break 2273 } 2274 } 2275 } 2276 } else { 2277 t.unknown_ = m 2278 } 2279 } else if i != nil { 2280 if !matched { 2281 t.IRI, err = IRIDeserialize(i) 2282 if err != nil { 2283 t.IRI = nil 2284 } else { 2285 matched = true 2286 } 2287 } 2288 } 2289 if !matched { 2290 t.unknown_ = unknownValueDeserialize(i) 2291 } 2292 return 2293 2294} 2295 2296// Serialize turns this object into an interface{}. 2297func (t *firstIntermediateType) Serialize() (i interface{}, err error) { 2298 if t.CollectionPage != nil { 2299 i, err = t.CollectionPage.Serialize() 2300 return 2301 } 2302 if t.Link != nil { 2303 i, err = t.Link.Serialize() 2304 return 2305 } 2306 if t.IRI != nil { 2307 i = IRISerialize(t.IRI) 2308 return 2309 } 2310 if t.OrderedCollectionPage != nil { 2311 i, err = t.OrderedCollectionPage.Serialize() 2312 return 2313 } 2314 i = unknownValueSerialize(t.unknown_) 2315 return 2316} 2317 2318// relationshipIntermediateType will only have one of its values set at most 2319type relationshipIntermediateType struct { 2320 // An unknown value. 2321 unknown_ interface{} 2322 // Stores possible ObjectType type for relationship property 2323 Object ObjectType 2324 // Stores possible *url.URL type for relationship property 2325 IRI *url.URL 2326} 2327 2328// Deserialize takes an interface{} and attempts to create a valid intermediate type. 2329func (t *relationshipIntermediateType) Deserialize(i interface{}) (err error) { 2330 matched := false 2331 if m, ok := i.(map[string]interface{}); ok { 2332 if tv, ok := m["type"]; ok { 2333 var types []string 2334 if tvs, ok := tv.([]interface{}); ok { 2335 for _, tvi := range tvs { 2336 if typeString, ok := tvi.(string); ok { 2337 types = append(types, typeString) 2338 } 2339 } 2340 } else if typeString, ok := tv.(string); ok { 2341 types = append(types, typeString) 2342 } 2343 if !matched { 2344 for _, kind := range types { 2345 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 2346 err = t.Object.Deserialize(m) 2347 matched = true 2348 break 2349 } 2350 } 2351 } 2352 } else { 2353 t.unknown_ = m 2354 } 2355 } else if i != nil { 2356 if !matched { 2357 t.IRI, err = IRIDeserialize(i) 2358 if err != nil { 2359 t.IRI = nil 2360 } else { 2361 matched = true 2362 } 2363 } 2364 } 2365 if !matched { 2366 t.unknown_ = unknownValueDeserialize(i) 2367 } 2368 return 2369 2370} 2371 2372// Serialize turns this object into an interface{}. 2373func (t *relationshipIntermediateType) Serialize() (i interface{}, err error) { 2374 if t.Object != nil { 2375 i, err = t.Object.Serialize() 2376 return 2377 } 2378 if t.IRI != nil { 2379 i = IRISerialize(t.IRI) 2380 return 2381 } 2382 i = unknownValueSerialize(t.unknown_) 2383 return 2384} 2385 2386// radiusIntermediateType will only have one of its values set at most 2387type radiusIntermediateType struct { 2388 // An unknown value. 2389 unknown_ interface{} 2390 // Stores possible *float64 type for radius property 2391 float *float64 2392 // Stores possible *url.URL type for radius property 2393 IRI *url.URL 2394} 2395 2396// Deserialize takes an interface{} and attempts to create a valid intermediate type. 2397func (t *radiusIntermediateType) Deserialize(i interface{}) (err error) { 2398 matched := false 2399 if m, ok := i.(map[string]interface{}); ok { 2400 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 2401 } else if i != nil { 2402 if !matched { 2403 t.float, err = floatDeserialize(i) 2404 if err != nil { 2405 t.float = nil 2406 } else { 2407 matched = true 2408 } 2409 } 2410 if !matched { 2411 t.IRI, err = IRIDeserialize(i) 2412 if err != nil { 2413 t.IRI = nil 2414 } else { 2415 matched = true 2416 } 2417 } 2418 } 2419 if !matched { 2420 t.unknown_ = unknownValueDeserialize(i) 2421 } 2422 return 2423 2424} 2425 2426// Serialize turns this object into an interface{}. 2427func (t *radiusIntermediateType) Serialize() (i interface{}, err error) { 2428 if t.float != nil { 2429 i = floatSerialize(*t.float) 2430 return 2431 } 2432 if t.IRI != nil { 2433 i = IRISerialize(t.IRI) 2434 return 2435 } 2436 i = unknownValueSerialize(t.unknown_) 2437 return 2438} 2439 2440// followingIntermediateType will only have one of its values set at most 2441type followingIntermediateType struct { 2442 // An unknown value. 2443 unknown_ interface{} 2444 // Stores possible CollectionType type for following property 2445 Collection CollectionType 2446 // Stores possible OrderedCollectionType type for following property 2447 OrderedCollection OrderedCollectionType 2448 // Stores possible *url.URL type for following property 2449 anyURI *url.URL 2450} 2451 2452// Deserialize takes an interface{} and attempts to create a valid intermediate type. 2453func (t *followingIntermediateType) Deserialize(i interface{}) (err error) { 2454 matched := false 2455 if m, ok := i.(map[string]interface{}); ok { 2456 if tv, ok := m["type"]; ok { 2457 var types []string 2458 if tvs, ok := tv.([]interface{}); ok { 2459 for _, tvi := range tvs { 2460 if typeString, ok := tvi.(string); ok { 2461 types = append(types, typeString) 2462 } 2463 } 2464 } else if typeString, ok := tv.(string); ok { 2465 types = append(types, typeString) 2466 } 2467 if !matched { 2468 for _, kind := range types { 2469 if t.Collection, ok = resolveObject(kind).(CollectionType); t.Collection != nil && ok { 2470 err = t.Collection.Deserialize(m) 2471 matched = true 2472 break 2473 } 2474 } 2475 } 2476 if !matched { 2477 for _, kind := range types { 2478 if t.OrderedCollection, ok = resolveObject(kind).(OrderedCollectionType); t.OrderedCollection != nil && ok { 2479 err = t.OrderedCollection.Deserialize(m) 2480 matched = true 2481 break 2482 } 2483 } 2484 } 2485 } else { 2486 t.unknown_ = m 2487 } 2488 } else if i != nil { 2489 if !matched { 2490 t.anyURI, err = anyURIDeserialize(i) 2491 if err != nil { 2492 t.anyURI = nil 2493 } else { 2494 matched = true 2495 } 2496 } 2497 } 2498 if !matched { 2499 t.unknown_ = unknownValueDeserialize(i) 2500 } 2501 return 2502 2503} 2504 2505// Serialize turns this object into an interface{}. 2506func (t *followingIntermediateType) Serialize() (i interface{}, err error) { 2507 if t.Collection != nil { 2508 i, err = t.Collection.Serialize() 2509 return 2510 } 2511 if t.OrderedCollection != nil { 2512 i, err = t.OrderedCollection.Serialize() 2513 return 2514 } 2515 if t.anyURI != nil { 2516 i = anyURISerialize(t.anyURI) 2517 return 2518 } 2519 i = unknownValueSerialize(t.unknown_) 2520 return 2521} 2522 2523// totalItemsIntermediateType will only have one of its values set at most 2524type totalItemsIntermediateType struct { 2525 // An unknown value. 2526 unknown_ interface{} 2527 // Stores possible *int64 type for totalItems property 2528 nonNegativeInteger *int64 2529 // Stores possible *url.URL type for totalItems property 2530 IRI *url.URL 2531} 2532 2533// Deserialize takes an interface{} and attempts to create a valid intermediate type. 2534func (t *totalItemsIntermediateType) Deserialize(i interface{}) (err error) { 2535 matched := false 2536 if m, ok := i.(map[string]interface{}); ok { 2537 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 2538 } else if i != nil { 2539 if !matched { 2540 t.nonNegativeInteger, err = nonNegativeIntegerDeserialize(i) 2541 if err != nil { 2542 t.nonNegativeInteger = nil 2543 } else { 2544 matched = true 2545 } 2546 } 2547 if !matched { 2548 t.IRI, err = IRIDeserialize(i) 2549 if err != nil { 2550 t.IRI = nil 2551 } else { 2552 matched = true 2553 } 2554 } 2555 } 2556 if !matched { 2557 t.unknown_ = unknownValueDeserialize(i) 2558 } 2559 return 2560 2561} 2562 2563// Serialize turns this object into an interface{}. 2564func (t *totalItemsIntermediateType) Serialize() (i interface{}, err error) { 2565 if t.nonNegativeInteger != nil { 2566 i = nonNegativeIntegerSerialize(*t.nonNegativeInteger) 2567 return 2568 } 2569 if t.IRI != nil { 2570 i = IRISerialize(t.IRI) 2571 return 2572 } 2573 i = unknownValueSerialize(t.unknown_) 2574 return 2575} 2576 2577// startIndexIntermediateType will only have one of its values set at most 2578type startIndexIntermediateType struct { 2579 // An unknown value. 2580 unknown_ interface{} 2581 // Stores possible *int64 type for startIndex property 2582 nonNegativeInteger *int64 2583 // Stores possible *url.URL type for startIndex property 2584 IRI *url.URL 2585} 2586 2587// Deserialize takes an interface{} and attempts to create a valid intermediate type. 2588func (t *startIndexIntermediateType) Deserialize(i interface{}) (err error) { 2589 matched := false 2590 if m, ok := i.(map[string]interface{}); ok { 2591 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 2592 } else if i != nil { 2593 if !matched { 2594 t.nonNegativeInteger, err = nonNegativeIntegerDeserialize(i) 2595 if err != nil { 2596 t.nonNegativeInteger = nil 2597 } else { 2598 matched = true 2599 } 2600 } 2601 if !matched { 2602 t.IRI, err = IRIDeserialize(i) 2603 if err != nil { 2604 t.IRI = nil 2605 } else { 2606 matched = true 2607 } 2608 } 2609 } 2610 if !matched { 2611 t.unknown_ = unknownValueDeserialize(i) 2612 } 2613 return 2614 2615} 2616 2617// Serialize turns this object into an interface{}. 2618func (t *startIndexIntermediateType) Serialize() (i interface{}, err error) { 2619 if t.nonNegativeInteger != nil { 2620 i = nonNegativeIntegerSerialize(*t.nonNegativeInteger) 2621 return 2622 } 2623 if t.IRI != nil { 2624 i = IRISerialize(t.IRI) 2625 return 2626 } 2627 i = unknownValueSerialize(t.unknown_) 2628 return 2629} 2630 2631// accuracyIntermediateType will only have one of its values set at most 2632type accuracyIntermediateType struct { 2633 // An unknown value. 2634 unknown_ interface{} 2635 // Stores possible *float64 type for accuracy property 2636 float *float64 2637 // Stores possible *url.URL type for accuracy property 2638 IRI *url.URL 2639} 2640 2641// Deserialize takes an interface{} and attempts to create a valid intermediate type. 2642func (t *accuracyIntermediateType) Deserialize(i interface{}) (err error) { 2643 matched := false 2644 if m, ok := i.(map[string]interface{}); ok { 2645 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 2646 } else if i != nil { 2647 if !matched { 2648 t.float, err = floatDeserialize(i) 2649 if err != nil { 2650 t.float = nil 2651 } else { 2652 matched = true 2653 } 2654 } 2655 if !matched { 2656 t.IRI, err = IRIDeserialize(i) 2657 if err != nil { 2658 t.IRI = nil 2659 } else { 2660 matched = true 2661 } 2662 } 2663 } 2664 if !matched { 2665 t.unknown_ = unknownValueDeserialize(i) 2666 } 2667 return 2668 2669} 2670 2671// Serialize turns this object into an interface{}. 2672func (t *accuracyIntermediateType) Serialize() (i interface{}, err error) { 2673 if t.float != nil { 2674 i = floatSerialize(*t.float) 2675 return 2676 } 2677 if t.IRI != nil { 2678 i = IRISerialize(t.IRI) 2679 return 2680 } 2681 i = unknownValueSerialize(t.unknown_) 2682 return 2683} 2684 2685// prevIntermediateType will only have one of its values set at most 2686type prevIntermediateType struct { 2687 // An unknown value. 2688 unknown_ interface{} 2689 // Stores possible CollectionPageType type for prev property 2690 CollectionPage CollectionPageType 2691 // Stores possible LinkType type for prev property 2692 Link LinkType 2693 // Stores possible *url.URL type for prev property 2694 IRI *url.URL 2695 // Stores possible OrderedCollectionPageType type for prev property 2696 OrderedCollectionPage OrderedCollectionPageType 2697} 2698 2699// Deserialize takes an interface{} and attempts to create a valid intermediate type. 2700func (t *prevIntermediateType) Deserialize(i interface{}) (err error) { 2701 matched := false 2702 if m, ok := i.(map[string]interface{}); ok { 2703 if tv, ok := m["type"]; ok { 2704 var types []string 2705 if tvs, ok := tv.([]interface{}); ok { 2706 for _, tvi := range tvs { 2707 if typeString, ok := tvi.(string); ok { 2708 types = append(types, typeString) 2709 } 2710 } 2711 } else if typeString, ok := tv.(string); ok { 2712 types = append(types, typeString) 2713 } 2714 if !matched { 2715 for _, kind := range types { 2716 if t.CollectionPage, ok = resolveObject(kind).(CollectionPageType); t.CollectionPage != nil && ok { 2717 err = t.CollectionPage.Deserialize(m) 2718 matched = true 2719 break 2720 } 2721 } 2722 } 2723 if !matched { 2724 for _, kind := range types { 2725 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 2726 err = t.Link.Deserialize(m) 2727 matched = true 2728 break 2729 } 2730 } 2731 } 2732 if !matched { 2733 for _, kind := range types { 2734 if t.OrderedCollectionPage, ok = resolveObject(kind).(OrderedCollectionPageType); t.OrderedCollectionPage != nil && ok { 2735 err = t.OrderedCollectionPage.Deserialize(m) 2736 matched = true 2737 break 2738 } 2739 } 2740 } 2741 } else { 2742 t.unknown_ = m 2743 } 2744 } else if i != nil { 2745 if !matched { 2746 t.IRI, err = IRIDeserialize(i) 2747 if err != nil { 2748 t.IRI = nil 2749 } else { 2750 matched = true 2751 } 2752 } 2753 } 2754 if !matched { 2755 t.unknown_ = unknownValueDeserialize(i) 2756 } 2757 return 2758 2759} 2760 2761// Serialize turns this object into an interface{}. 2762func (t *prevIntermediateType) Serialize() (i interface{}, err error) { 2763 if t.CollectionPage != nil { 2764 i, err = t.CollectionPage.Serialize() 2765 return 2766 } 2767 if t.Link != nil { 2768 i, err = t.Link.Serialize() 2769 return 2770 } 2771 if t.IRI != nil { 2772 i = IRISerialize(t.IRI) 2773 return 2774 } 2775 if t.OrderedCollectionPage != nil { 2776 i, err = t.OrderedCollectionPage.Serialize() 2777 return 2778 } 2779 i = unknownValueSerialize(t.unknown_) 2780 return 2781} 2782 2783// publishedIntermediateType will only have one of its values set at most 2784type publishedIntermediateType struct { 2785 // An unknown value. 2786 unknown_ interface{} 2787 // Stores possible *time.Time type for published property 2788 dateTime *time.Time 2789 // Stores possible *url.URL type for published property 2790 IRI *url.URL 2791} 2792 2793// Deserialize takes an interface{} and attempts to create a valid intermediate type. 2794func (t *publishedIntermediateType) Deserialize(i interface{}) (err error) { 2795 matched := false 2796 if m, ok := i.(map[string]interface{}); ok { 2797 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 2798 } else if i != nil { 2799 if !matched { 2800 t.dateTime, err = dateTimeDeserialize(i) 2801 if err != nil { 2802 t.dateTime = nil 2803 } else { 2804 matched = true 2805 } 2806 } 2807 if !matched { 2808 t.IRI, err = IRIDeserialize(i) 2809 if err != nil { 2810 t.IRI = nil 2811 } else { 2812 matched = true 2813 } 2814 } 2815 } 2816 if !matched { 2817 t.unknown_ = unknownValueDeserialize(i) 2818 } 2819 return 2820 2821} 2822 2823// Serialize turns this object into an interface{}. 2824func (t *publishedIntermediateType) Serialize() (i interface{}, err error) { 2825 if t.dateTime != nil { 2826 i = dateTimeSerialize(*t.dateTime) 2827 return 2828 } 2829 if t.IRI != nil { 2830 i = IRISerialize(t.IRI) 2831 return 2832 } 2833 i = unknownValueSerialize(t.unknown_) 2834 return 2835} 2836 2837// updatedIntermediateType will only have one of its values set at most 2838type updatedIntermediateType struct { 2839 // An unknown value. 2840 unknown_ interface{} 2841 // Stores possible *time.Time type for updated property 2842 dateTime *time.Time 2843 // Stores possible *url.URL type for updated property 2844 IRI *url.URL 2845} 2846 2847// Deserialize takes an interface{} and attempts to create a valid intermediate type. 2848func (t *updatedIntermediateType) Deserialize(i interface{}) (err error) { 2849 matched := false 2850 if m, ok := i.(map[string]interface{}); ok { 2851 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 2852 } else if i != nil { 2853 if !matched { 2854 t.dateTime, err = dateTimeDeserialize(i) 2855 if err != nil { 2856 t.dateTime = nil 2857 } else { 2858 matched = true 2859 } 2860 } 2861 if !matched { 2862 t.IRI, err = IRIDeserialize(i) 2863 if err != nil { 2864 t.IRI = nil 2865 } else { 2866 matched = true 2867 } 2868 } 2869 } 2870 if !matched { 2871 t.unknown_ = unknownValueDeserialize(i) 2872 } 2873 return 2874 2875} 2876 2877// Serialize turns this object into an interface{}. 2878func (t *updatedIntermediateType) Serialize() (i interface{}, err error) { 2879 if t.dateTime != nil { 2880 i = dateTimeSerialize(*t.dateTime) 2881 return 2882 } 2883 if t.IRI != nil { 2884 i = IRISerialize(t.IRI) 2885 return 2886 } 2887 i = unknownValueSerialize(t.unknown_) 2888 return 2889} 2890 2891// actorIntermediateType will only have one of its values set at most 2892type actorIntermediateType struct { 2893 // An unknown value. 2894 unknown_ interface{} 2895 // Stores possible ObjectType type for actor property 2896 Object ObjectType 2897 // Stores possible LinkType type for actor property 2898 Link LinkType 2899 // Stores possible *url.URL type for actor property 2900 IRI *url.URL 2901} 2902 2903// Deserialize takes an interface{} and attempts to create a valid intermediate type. 2904func (t *actorIntermediateType) Deserialize(i interface{}) (err error) { 2905 matched := false 2906 if m, ok := i.(map[string]interface{}); ok { 2907 if tv, ok := m["type"]; ok { 2908 var types []string 2909 if tvs, ok := tv.([]interface{}); ok { 2910 for _, tvi := range tvs { 2911 if typeString, ok := tvi.(string); ok { 2912 types = append(types, typeString) 2913 } 2914 } 2915 } else if typeString, ok := tv.(string); ok { 2916 types = append(types, typeString) 2917 } 2918 if !matched { 2919 for _, kind := range types { 2920 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 2921 err = t.Object.Deserialize(m) 2922 matched = true 2923 break 2924 } 2925 } 2926 } 2927 if !matched { 2928 for _, kind := range types { 2929 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 2930 err = t.Link.Deserialize(m) 2931 matched = true 2932 break 2933 } 2934 } 2935 } 2936 } else { 2937 t.unknown_ = m 2938 } 2939 } else if i != nil { 2940 if !matched { 2941 t.IRI, err = IRIDeserialize(i) 2942 if err != nil { 2943 t.IRI = nil 2944 } else { 2945 matched = true 2946 } 2947 } 2948 } 2949 if !matched { 2950 t.unknown_ = unknownValueDeserialize(i) 2951 } 2952 return 2953 2954} 2955 2956// Serialize turns this object into an interface{}. 2957func (t *actorIntermediateType) Serialize() (i interface{}, err error) { 2958 if t.Object != nil { 2959 i, err = t.Object.Serialize() 2960 return 2961 } 2962 if t.Link != nil { 2963 i, err = t.Link.Serialize() 2964 return 2965 } 2966 if t.IRI != nil { 2967 i = IRISerialize(t.IRI) 2968 return 2969 } 2970 i = unknownValueSerialize(t.unknown_) 2971 return 2972} 2973 2974// objectIntermediateType will only have one of its values set at most 2975type objectIntermediateType struct { 2976 // An unknown value. 2977 unknown_ interface{} 2978 // Stores possible ObjectType type for object property 2979 Object ObjectType 2980 // Stores possible *url.URL type for object property 2981 IRI *url.URL 2982} 2983 2984// Deserialize takes an interface{} and attempts to create a valid intermediate type. 2985func (t *objectIntermediateType) Deserialize(i interface{}) (err error) { 2986 matched := false 2987 if m, ok := i.(map[string]interface{}); ok { 2988 if tv, ok := m["type"]; ok { 2989 var types []string 2990 if tvs, ok := tv.([]interface{}); ok { 2991 for _, tvi := range tvs { 2992 if typeString, ok := tvi.(string); ok { 2993 types = append(types, typeString) 2994 } 2995 } 2996 } else if typeString, ok := tv.(string); ok { 2997 types = append(types, typeString) 2998 } 2999 if !matched { 3000 for _, kind := range types { 3001 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 3002 err = t.Object.Deserialize(m) 3003 matched = true 3004 break 3005 } 3006 } 3007 } 3008 } else { 3009 t.unknown_ = m 3010 } 3011 } else if i != nil { 3012 if !matched { 3013 t.IRI, err = IRIDeserialize(i) 3014 if err != nil { 3015 t.IRI = nil 3016 } else { 3017 matched = true 3018 } 3019 } 3020 } 3021 if !matched { 3022 t.unknown_ = unknownValueDeserialize(i) 3023 } 3024 return 3025 3026} 3027 3028// Serialize turns this object into an interface{}. 3029func (t *objectIntermediateType) Serialize() (i interface{}, err error) { 3030 if t.Object != nil { 3031 i, err = t.Object.Serialize() 3032 return 3033 } 3034 if t.IRI != nil { 3035 i = IRISerialize(t.IRI) 3036 return 3037 } 3038 i = unknownValueSerialize(t.unknown_) 3039 return 3040} 3041 3042// currentIntermediateType will only have one of its values set at most 3043type currentIntermediateType struct { 3044 // An unknown value. 3045 unknown_ interface{} 3046 // Stores possible CollectionPageType type for current property 3047 CollectionPage CollectionPageType 3048 // Stores possible LinkType type for current property 3049 Link LinkType 3050 // Stores possible *url.URL type for current property 3051 IRI *url.URL 3052 // Stores possible OrderedCollectionPageType type for current property 3053 OrderedCollectionPage OrderedCollectionPageType 3054} 3055 3056// Deserialize takes an interface{} and attempts to create a valid intermediate type. 3057func (t *currentIntermediateType) Deserialize(i interface{}) (err error) { 3058 matched := false 3059 if m, ok := i.(map[string]interface{}); ok { 3060 if tv, ok := m["type"]; ok { 3061 var types []string 3062 if tvs, ok := tv.([]interface{}); ok { 3063 for _, tvi := range tvs { 3064 if typeString, ok := tvi.(string); ok { 3065 types = append(types, typeString) 3066 } 3067 } 3068 } else if typeString, ok := tv.(string); ok { 3069 types = append(types, typeString) 3070 } 3071 if !matched { 3072 for _, kind := range types { 3073 if t.CollectionPage, ok = resolveObject(kind).(CollectionPageType); t.CollectionPage != nil && ok { 3074 err = t.CollectionPage.Deserialize(m) 3075 matched = true 3076 break 3077 } 3078 } 3079 } 3080 if !matched { 3081 for _, kind := range types { 3082 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 3083 err = t.Link.Deserialize(m) 3084 matched = true 3085 break 3086 } 3087 } 3088 } 3089 if !matched { 3090 for _, kind := range types { 3091 if t.OrderedCollectionPage, ok = resolveObject(kind).(OrderedCollectionPageType); t.OrderedCollectionPage != nil && ok { 3092 err = t.OrderedCollectionPage.Deserialize(m) 3093 matched = true 3094 break 3095 } 3096 } 3097 } 3098 } else { 3099 t.unknown_ = m 3100 } 3101 } else if i != nil { 3102 if !matched { 3103 t.IRI, err = IRIDeserialize(i) 3104 if err != nil { 3105 t.IRI = nil 3106 } else { 3107 matched = true 3108 } 3109 } 3110 } 3111 if !matched { 3112 t.unknown_ = unknownValueDeserialize(i) 3113 } 3114 return 3115 3116} 3117 3118// Serialize turns this object into an interface{}. 3119func (t *currentIntermediateType) Serialize() (i interface{}, err error) { 3120 if t.CollectionPage != nil { 3121 i, err = t.CollectionPage.Serialize() 3122 return 3123 } 3124 if t.Link != nil { 3125 i, err = t.Link.Serialize() 3126 return 3127 } 3128 if t.IRI != nil { 3129 i = IRISerialize(t.IRI) 3130 return 3131 } 3132 if t.OrderedCollectionPage != nil { 3133 i, err = t.OrderedCollectionPage.Serialize() 3134 return 3135 } 3136 i = unknownValueSerialize(t.unknown_) 3137 return 3138} 3139 3140// formerTypeIntermediateType will only have one of its values set at most 3141type formerTypeIntermediateType struct { 3142 // An unknown value. 3143 unknown_ interface{} 3144 // Stores possible *string type for formerType property 3145 stringName *string 3146 // Stores possible ObjectType type for formerType property 3147 Object ObjectType 3148 // Stores possible *url.URL type for formerType property 3149 IRI *url.URL 3150} 3151 3152// Deserialize takes an interface{} and attempts to create a valid intermediate type. 3153func (t *formerTypeIntermediateType) Deserialize(i interface{}) (err error) { 3154 matched := false 3155 if m, ok := i.(map[string]interface{}); ok { 3156 if tv, ok := m["type"]; ok { 3157 var types []string 3158 if tvs, ok := tv.([]interface{}); ok { 3159 for _, tvi := range tvs { 3160 if typeString, ok := tvi.(string); ok { 3161 types = append(types, typeString) 3162 } 3163 } 3164 } else if typeString, ok := tv.(string); ok { 3165 types = append(types, typeString) 3166 } 3167 if !matched { 3168 for _, kind := range types { 3169 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 3170 err = t.Object.Deserialize(m) 3171 matched = true 3172 break 3173 } 3174 } 3175 } 3176 } else { 3177 t.unknown_ = m 3178 } 3179 } else if i != nil { 3180 if !matched { 3181 t.stringName, err = stringDeserialize(i) 3182 if err != nil { 3183 t.stringName = nil 3184 } else { 3185 matched = true 3186 } 3187 } 3188 if !matched { 3189 t.IRI, err = IRIDeserialize(i) 3190 if err != nil { 3191 t.IRI = nil 3192 } else { 3193 matched = true 3194 } 3195 } 3196 } 3197 if !matched { 3198 t.unknown_ = unknownValueDeserialize(i) 3199 } 3200 return 3201 3202} 3203 3204// Serialize turns this object into an interface{}. 3205func (t *formerTypeIntermediateType) Serialize() (i interface{}, err error) { 3206 if t.stringName != nil { 3207 i = stringSerialize(*t.stringName) 3208 return 3209 } 3210 if t.Object != nil { 3211 i, err = t.Object.Serialize() 3212 return 3213 } 3214 if t.IRI != nil { 3215 i = IRISerialize(t.IRI) 3216 return 3217 } 3218 i = unknownValueSerialize(t.unknown_) 3219 return 3220} 3221 3222// iconIntermediateType will only have one of its values set at most 3223type iconIntermediateType struct { 3224 // An unknown value. 3225 unknown_ interface{} 3226 // Stores possible ImageType type for icon property 3227 Image ImageType 3228 // Stores possible LinkType type for icon property 3229 Link LinkType 3230 // Stores possible *url.URL type for icon property 3231 IRI *url.URL 3232} 3233 3234// Deserialize takes an interface{} and attempts to create a valid intermediate type. 3235func (t *iconIntermediateType) Deserialize(i interface{}) (err error) { 3236 matched := false 3237 if m, ok := i.(map[string]interface{}); ok { 3238 if tv, ok := m["type"]; ok { 3239 var types []string 3240 if tvs, ok := tv.([]interface{}); ok { 3241 for _, tvi := range tvs { 3242 if typeString, ok := tvi.(string); ok { 3243 types = append(types, typeString) 3244 } 3245 } 3246 } else if typeString, ok := tv.(string); ok { 3247 types = append(types, typeString) 3248 } 3249 if !matched { 3250 for _, kind := range types { 3251 if t.Image, ok = resolveObject(kind).(ImageType); t.Image != nil && ok { 3252 err = t.Image.Deserialize(m) 3253 matched = true 3254 break 3255 } 3256 } 3257 } 3258 if !matched { 3259 for _, kind := range types { 3260 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 3261 err = t.Link.Deserialize(m) 3262 matched = true 3263 break 3264 } 3265 } 3266 } 3267 } else { 3268 t.unknown_ = m 3269 } 3270 } else if i != nil { 3271 if !matched { 3272 t.IRI, err = IRIDeserialize(i) 3273 if err != nil { 3274 t.IRI = nil 3275 } else { 3276 matched = true 3277 } 3278 } 3279 } 3280 if !matched { 3281 t.unknown_ = unknownValueDeserialize(i) 3282 } 3283 return 3284 3285} 3286 3287// Serialize turns this object into an interface{}. 3288func (t *iconIntermediateType) Serialize() (i interface{}, err error) { 3289 if t.Image != nil { 3290 i, err = t.Image.Serialize() 3291 return 3292 } 3293 if t.Link != nil { 3294 i, err = t.Link.Serialize() 3295 return 3296 } 3297 if t.IRI != nil { 3298 i = IRISerialize(t.IRI) 3299 return 3300 } 3301 i = unknownValueSerialize(t.unknown_) 3302 return 3303} 3304 3305// relIntermediateType will only have one of its values set at most 3306type relIntermediateType struct { 3307 // An unknown value. 3308 unknown_ interface{} 3309 // Stores possible *string type for rel property 3310 linkRelation *string 3311 // Stores possible *url.URL type for rel property 3312 IRI *url.URL 3313} 3314 3315// Deserialize takes an interface{} and attempts to create a valid intermediate type. 3316func (t *relIntermediateType) Deserialize(i interface{}) (err error) { 3317 matched := false 3318 if m, ok := i.(map[string]interface{}); ok { 3319 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 3320 } else if i != nil { 3321 if !matched { 3322 t.linkRelation, err = linkRelationDeserialize(i) 3323 if err != nil { 3324 t.linkRelation = nil 3325 } else { 3326 matched = true 3327 } 3328 } 3329 if !matched { 3330 t.IRI, err = IRIDeserialize(i) 3331 if err != nil { 3332 t.IRI = nil 3333 } else { 3334 matched = true 3335 } 3336 } 3337 } 3338 if !matched { 3339 t.unknown_ = unknownValueDeserialize(i) 3340 } 3341 return 3342 3343} 3344 3345// Serialize turns this object into an interface{}. 3346func (t *relIntermediateType) Serialize() (i interface{}, err error) { 3347 if t.linkRelation != nil { 3348 i = linkRelationSerialize(*t.linkRelation) 3349 return 3350 } 3351 if t.IRI != nil { 3352 i = IRISerialize(t.IRI) 3353 return 3354 } 3355 i = unknownValueSerialize(t.unknown_) 3356 return 3357} 3358 3359// originIntermediateType will only have one of its values set at most 3360type originIntermediateType struct { 3361 // An unknown value. 3362 unknown_ interface{} 3363 // Stores possible ObjectType type for origin property 3364 Object ObjectType 3365 // Stores possible LinkType type for origin property 3366 Link LinkType 3367 // Stores possible *url.URL type for origin property 3368 IRI *url.URL 3369} 3370 3371// Deserialize takes an interface{} and attempts to create a valid intermediate type. 3372func (t *originIntermediateType) Deserialize(i interface{}) (err error) { 3373 matched := false 3374 if m, ok := i.(map[string]interface{}); ok { 3375 if tv, ok := m["type"]; ok { 3376 var types []string 3377 if tvs, ok := tv.([]interface{}); ok { 3378 for _, tvi := range tvs { 3379 if typeString, ok := tvi.(string); ok { 3380 types = append(types, typeString) 3381 } 3382 } 3383 } else if typeString, ok := tv.(string); ok { 3384 types = append(types, typeString) 3385 } 3386 if !matched { 3387 for _, kind := range types { 3388 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 3389 err = t.Object.Deserialize(m) 3390 matched = true 3391 break 3392 } 3393 } 3394 } 3395 if !matched { 3396 for _, kind := range types { 3397 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 3398 err = t.Link.Deserialize(m) 3399 matched = true 3400 break 3401 } 3402 } 3403 } 3404 } else { 3405 t.unknown_ = m 3406 } 3407 } else if i != nil { 3408 if !matched { 3409 t.IRI, err = IRIDeserialize(i) 3410 if err != nil { 3411 t.IRI = nil 3412 } else { 3413 matched = true 3414 } 3415 } 3416 } 3417 if !matched { 3418 t.unknown_ = unknownValueDeserialize(i) 3419 } 3420 return 3421 3422} 3423 3424// Serialize turns this object into an interface{}. 3425func (t *originIntermediateType) Serialize() (i interface{}, err error) { 3426 if t.Object != nil { 3427 i, err = t.Object.Serialize() 3428 return 3429 } 3430 if t.Link != nil { 3431 i, err = t.Link.Serialize() 3432 return 3433 } 3434 if t.IRI != nil { 3435 i = IRISerialize(t.IRI) 3436 return 3437 } 3438 i = unknownValueSerialize(t.unknown_) 3439 return 3440} 3441 3442// orderedItemsIntermediateType will only have one of its values set at most 3443type orderedItemsIntermediateType struct { 3444 // An unknown value. 3445 unknown_ interface{} 3446 // Stores possible ObjectType type for orderedItems property 3447 Object ObjectType 3448 // Stores possible LinkType type for orderedItems property 3449 Link LinkType 3450 // Stores possible *url.URL type for orderedItems property 3451 IRI *url.URL 3452} 3453 3454// Deserialize takes an interface{} and attempts to create a valid intermediate type. 3455func (t *orderedItemsIntermediateType) Deserialize(i interface{}) (err error) { 3456 matched := false 3457 if m, ok := i.(map[string]interface{}); ok { 3458 if tv, ok := m["type"]; ok { 3459 var types []string 3460 if tvs, ok := tv.([]interface{}); ok { 3461 for _, tvi := range tvs { 3462 if typeString, ok := tvi.(string); ok { 3463 types = append(types, typeString) 3464 } 3465 } 3466 } else if typeString, ok := tv.(string); ok { 3467 types = append(types, typeString) 3468 } 3469 if !matched { 3470 for _, kind := range types { 3471 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 3472 err = t.Object.Deserialize(m) 3473 matched = true 3474 break 3475 } 3476 } 3477 } 3478 if !matched { 3479 for _, kind := range types { 3480 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 3481 err = t.Link.Deserialize(m) 3482 matched = true 3483 break 3484 } 3485 } 3486 } 3487 } else { 3488 t.unknown_ = m 3489 } 3490 } else if i != nil { 3491 if !matched { 3492 t.IRI, err = IRIDeserialize(i) 3493 if err != nil { 3494 t.IRI = nil 3495 } else { 3496 matched = true 3497 } 3498 } 3499 } 3500 if !matched { 3501 t.unknown_ = unknownValueDeserialize(i) 3502 } 3503 return 3504 3505} 3506 3507// Serialize turns this object into an interface{}. 3508func (t *orderedItemsIntermediateType) Serialize() (i interface{}, err error) { 3509 if t.Object != nil { 3510 i, err = t.Object.Serialize() 3511 return 3512 } 3513 if t.Link != nil { 3514 i, err = t.Link.Serialize() 3515 return 3516 } 3517 if t.IRI != nil { 3518 i = IRISerialize(t.IRI) 3519 return 3520 } 3521 i = unknownValueSerialize(t.unknown_) 3522 return 3523} 3524 3525// nextIntermediateType will only have one of its values set at most 3526type nextIntermediateType struct { 3527 // An unknown value. 3528 unknown_ interface{} 3529 // Stores possible CollectionPageType type for next property 3530 CollectionPage CollectionPageType 3531 // Stores possible LinkType type for next property 3532 Link LinkType 3533 // Stores possible *url.URL type for next property 3534 IRI *url.URL 3535 // Stores possible OrderedCollectionPageType type for next property 3536 OrderedCollectionPage OrderedCollectionPageType 3537} 3538 3539// Deserialize takes an interface{} and attempts to create a valid intermediate type. 3540func (t *nextIntermediateType) Deserialize(i interface{}) (err error) { 3541 matched := false 3542 if m, ok := i.(map[string]interface{}); ok { 3543 if tv, ok := m["type"]; ok { 3544 var types []string 3545 if tvs, ok := tv.([]interface{}); ok { 3546 for _, tvi := range tvs { 3547 if typeString, ok := tvi.(string); ok { 3548 types = append(types, typeString) 3549 } 3550 } 3551 } else if typeString, ok := tv.(string); ok { 3552 types = append(types, typeString) 3553 } 3554 if !matched { 3555 for _, kind := range types { 3556 if t.CollectionPage, ok = resolveObject(kind).(CollectionPageType); t.CollectionPage != nil && ok { 3557 err = t.CollectionPage.Deserialize(m) 3558 matched = true 3559 break 3560 } 3561 } 3562 } 3563 if !matched { 3564 for _, kind := range types { 3565 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 3566 err = t.Link.Deserialize(m) 3567 matched = true 3568 break 3569 } 3570 } 3571 } 3572 if !matched { 3573 for _, kind := range types { 3574 if t.OrderedCollectionPage, ok = resolveObject(kind).(OrderedCollectionPageType); t.OrderedCollectionPage != nil && ok { 3575 err = t.OrderedCollectionPage.Deserialize(m) 3576 matched = true 3577 break 3578 } 3579 } 3580 } 3581 } else { 3582 t.unknown_ = m 3583 } 3584 } else if i != nil { 3585 if !matched { 3586 t.IRI, err = IRIDeserialize(i) 3587 if err != nil { 3588 t.IRI = nil 3589 } else { 3590 matched = true 3591 } 3592 } 3593 } 3594 if !matched { 3595 t.unknown_ = unknownValueDeserialize(i) 3596 } 3597 return 3598 3599} 3600 3601// Serialize turns this object into an interface{}. 3602func (t *nextIntermediateType) Serialize() (i interface{}, err error) { 3603 if t.CollectionPage != nil { 3604 i, err = t.CollectionPage.Serialize() 3605 return 3606 } 3607 if t.Link != nil { 3608 i, err = t.Link.Serialize() 3609 return 3610 } 3611 if t.IRI != nil { 3612 i = IRISerialize(t.IRI) 3613 return 3614 } 3615 if t.OrderedCollectionPage != nil { 3616 i, err = t.OrderedCollectionPage.Serialize() 3617 return 3618 } 3619 i = unknownValueSerialize(t.unknown_) 3620 return 3621} 3622 3623// inReplyToIntermediateType will only have one of its values set at most 3624type inReplyToIntermediateType struct { 3625 // An unknown value. 3626 unknown_ interface{} 3627 // Stores possible ObjectType type for inReplyTo property 3628 Object ObjectType 3629 // Stores possible LinkType type for inReplyTo property 3630 Link LinkType 3631 // Stores possible *url.URL type for inReplyTo property 3632 IRI *url.URL 3633} 3634 3635// Deserialize takes an interface{} and attempts to create a valid intermediate type. 3636func (t *inReplyToIntermediateType) Deserialize(i interface{}) (err error) { 3637 matched := false 3638 if m, ok := i.(map[string]interface{}); ok { 3639 if tv, ok := m["type"]; ok { 3640 var types []string 3641 if tvs, ok := tv.([]interface{}); ok { 3642 for _, tvi := range tvs { 3643 if typeString, ok := tvi.(string); ok { 3644 types = append(types, typeString) 3645 } 3646 } 3647 } else if typeString, ok := tv.(string); ok { 3648 types = append(types, typeString) 3649 } 3650 if !matched { 3651 for _, kind := range types { 3652 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 3653 err = t.Object.Deserialize(m) 3654 matched = true 3655 break 3656 } 3657 } 3658 } 3659 if !matched { 3660 for _, kind := range types { 3661 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 3662 err = t.Link.Deserialize(m) 3663 matched = true 3664 break 3665 } 3666 } 3667 } 3668 } else { 3669 t.unknown_ = m 3670 } 3671 } else if i != nil { 3672 if !matched { 3673 t.IRI, err = IRIDeserialize(i) 3674 if err != nil { 3675 t.IRI = nil 3676 } else { 3677 matched = true 3678 } 3679 } 3680 } 3681 if !matched { 3682 t.unknown_ = unknownValueDeserialize(i) 3683 } 3684 return 3685 3686} 3687 3688// Serialize turns this object into an interface{}. 3689func (t *inReplyToIntermediateType) Serialize() (i interface{}, err error) { 3690 if t.Object != nil { 3691 i, err = t.Object.Serialize() 3692 return 3693 } 3694 if t.Link != nil { 3695 i, err = t.Link.Serialize() 3696 return 3697 } 3698 if t.IRI != nil { 3699 i = IRISerialize(t.IRI) 3700 return 3701 } 3702 i = unknownValueSerialize(t.unknown_) 3703 return 3704} 3705 3706// btoIntermediateType will only have one of its values set at most 3707type btoIntermediateType struct { 3708 // An unknown value. 3709 unknown_ interface{} 3710 // Stores possible ObjectType type for bto property 3711 Object ObjectType 3712 // Stores possible LinkType type for bto property 3713 Link LinkType 3714 // Stores possible *url.URL type for bto property 3715 IRI *url.URL 3716} 3717 3718// Deserialize takes an interface{} and attempts to create a valid intermediate type. 3719func (t *btoIntermediateType) Deserialize(i interface{}) (err error) { 3720 matched := false 3721 if m, ok := i.(map[string]interface{}); ok { 3722 if tv, ok := m["type"]; ok { 3723 var types []string 3724 if tvs, ok := tv.([]interface{}); ok { 3725 for _, tvi := range tvs { 3726 if typeString, ok := tvi.(string); ok { 3727 types = append(types, typeString) 3728 } 3729 } 3730 } else if typeString, ok := tv.(string); ok { 3731 types = append(types, typeString) 3732 } 3733 if !matched { 3734 for _, kind := range types { 3735 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 3736 err = t.Object.Deserialize(m) 3737 matched = true 3738 break 3739 } 3740 } 3741 } 3742 if !matched { 3743 for _, kind := range types { 3744 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 3745 err = t.Link.Deserialize(m) 3746 matched = true 3747 break 3748 } 3749 } 3750 } 3751 } else { 3752 t.unknown_ = m 3753 } 3754 } else if i != nil { 3755 if !matched { 3756 t.IRI, err = IRIDeserialize(i) 3757 if err != nil { 3758 t.IRI = nil 3759 } else { 3760 matched = true 3761 } 3762 } 3763 } 3764 if !matched { 3765 t.unknown_ = unknownValueDeserialize(i) 3766 } 3767 return 3768 3769} 3770 3771// Serialize turns this object into an interface{}. 3772func (t *btoIntermediateType) Serialize() (i interface{}, err error) { 3773 if t.Object != nil { 3774 i, err = t.Object.Serialize() 3775 return 3776 } 3777 if t.Link != nil { 3778 i, err = t.Link.Serialize() 3779 return 3780 } 3781 if t.IRI != nil { 3782 i = IRISerialize(t.IRI) 3783 return 3784 } 3785 i = unknownValueSerialize(t.unknown_) 3786 return 3787} 3788 3789// mediaTypeIntermediateType will only have one of its values set at most 3790type mediaTypeIntermediateType struct { 3791 // An unknown value. 3792 unknown_ interface{} 3793 // Stores possible *string type for mediaType property 3794 mimeMediaTypeValue *string 3795 // Stores possible *url.URL type for mediaType property 3796 IRI *url.URL 3797} 3798 3799// Deserialize takes an interface{} and attempts to create a valid intermediate type. 3800func (t *mediaTypeIntermediateType) Deserialize(i interface{}) (err error) { 3801 matched := false 3802 if m, ok := i.(map[string]interface{}); ok { 3803 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 3804 } else if i != nil { 3805 if !matched { 3806 t.mimeMediaTypeValue, err = mimeMediaTypeValueDeserialize(i) 3807 if err != nil { 3808 t.mimeMediaTypeValue = nil 3809 } else { 3810 matched = true 3811 } 3812 } 3813 if !matched { 3814 t.IRI, err = IRIDeserialize(i) 3815 if err != nil { 3816 t.IRI = nil 3817 } else { 3818 matched = true 3819 } 3820 } 3821 } 3822 if !matched { 3823 t.unknown_ = unknownValueDeserialize(i) 3824 } 3825 return 3826 3827} 3828 3829// Serialize turns this object into an interface{}. 3830func (t *mediaTypeIntermediateType) Serialize() (i interface{}, err error) { 3831 if t.mimeMediaTypeValue != nil { 3832 i = mimeMediaTypeValueSerialize(*t.mimeMediaTypeValue) 3833 return 3834 } 3835 if t.IRI != nil { 3836 i = IRISerialize(t.IRI) 3837 return 3838 } 3839 i = unknownValueSerialize(t.unknown_) 3840 return 3841} 3842 3843// endTimeIntermediateType will only have one of its values set at most 3844type endTimeIntermediateType struct { 3845 // An unknown value. 3846 unknown_ interface{} 3847 // Stores possible *time.Time type for endTime property 3848 dateTime *time.Time 3849 // Stores possible *url.URL type for endTime property 3850 IRI *url.URL 3851} 3852 3853// Deserialize takes an interface{} and attempts to create a valid intermediate type. 3854func (t *endTimeIntermediateType) Deserialize(i interface{}) (err error) { 3855 matched := false 3856 if m, ok := i.(map[string]interface{}); ok { 3857 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 3858 } else if i != nil { 3859 if !matched { 3860 t.dateTime, err = dateTimeDeserialize(i) 3861 if err != nil { 3862 t.dateTime = nil 3863 } else { 3864 matched = true 3865 } 3866 } 3867 if !matched { 3868 t.IRI, err = IRIDeserialize(i) 3869 if err != nil { 3870 t.IRI = nil 3871 } else { 3872 matched = true 3873 } 3874 } 3875 } 3876 if !matched { 3877 t.unknown_ = unknownValueDeserialize(i) 3878 } 3879 return 3880 3881} 3882 3883// Serialize turns this object into an interface{}. 3884func (t *endTimeIntermediateType) Serialize() (i interface{}, err error) { 3885 if t.dateTime != nil { 3886 i = dateTimeSerialize(*t.dateTime) 3887 return 3888 } 3889 if t.IRI != nil { 3890 i = IRISerialize(t.IRI) 3891 return 3892 } 3893 i = unknownValueSerialize(t.unknown_) 3894 return 3895} 3896 3897// urlIntermediateType will only have one of its values set at most 3898type urlIntermediateType struct { 3899 // An unknown value. 3900 unknown_ interface{} 3901 // Stores possible *url.URL type for url property 3902 anyURI *url.URL 3903 // Stores possible LinkType type for url property 3904 Link LinkType 3905} 3906 3907// Deserialize takes an interface{} and attempts to create a valid intermediate type. 3908func (t *urlIntermediateType) Deserialize(i interface{}) (err error) { 3909 matched := false 3910 if m, ok := i.(map[string]interface{}); ok { 3911 if tv, ok := m["type"]; ok { 3912 var types []string 3913 if tvs, ok := tv.([]interface{}); ok { 3914 for _, tvi := range tvs { 3915 if typeString, ok := tvi.(string); ok { 3916 types = append(types, typeString) 3917 } 3918 } 3919 } else if typeString, ok := tv.(string); ok { 3920 types = append(types, typeString) 3921 } 3922 if !matched { 3923 for _, kind := range types { 3924 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 3925 err = t.Link.Deserialize(m) 3926 matched = true 3927 break 3928 } 3929 } 3930 } 3931 } else { 3932 t.unknown_ = m 3933 } 3934 } else if i != nil { 3935 if !matched { 3936 t.anyURI, err = anyURIDeserialize(i) 3937 if err != nil { 3938 t.anyURI = nil 3939 } else { 3940 matched = true 3941 } 3942 } 3943 } 3944 if !matched { 3945 t.unknown_ = unknownValueDeserialize(i) 3946 } 3947 return 3948 3949} 3950 3951// Serialize turns this object into an interface{}. 3952func (t *urlIntermediateType) Serialize() (i interface{}, err error) { 3953 if t.anyURI != nil { 3954 i = anyURISerialize(t.anyURI) 3955 return 3956 } 3957 if t.Link != nil { 3958 i, err = t.Link.Serialize() 3959 return 3960 } 3961 i = unknownValueSerialize(t.unknown_) 3962 return 3963} 3964 3965// widthIntermediateType will only have one of its values set at most 3966type widthIntermediateType struct { 3967 // An unknown value. 3968 unknown_ interface{} 3969 // Stores possible *int64 type for width property 3970 nonNegativeInteger *int64 3971 // Stores possible *url.URL type for width property 3972 IRI *url.URL 3973} 3974 3975// Deserialize takes an interface{} and attempts to create a valid intermediate type. 3976func (t *widthIntermediateType) Deserialize(i interface{}) (err error) { 3977 matched := false 3978 if m, ok := i.(map[string]interface{}); ok { 3979 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 3980 } else if i != nil { 3981 if !matched { 3982 t.nonNegativeInteger, err = nonNegativeIntegerDeserialize(i) 3983 if err != nil { 3984 t.nonNegativeInteger = nil 3985 } else { 3986 matched = true 3987 } 3988 } 3989 if !matched { 3990 t.IRI, err = IRIDeserialize(i) 3991 if err != nil { 3992 t.IRI = nil 3993 } else { 3994 matched = true 3995 } 3996 } 3997 } 3998 if !matched { 3999 t.unknown_ = unknownValueDeserialize(i) 4000 } 4001 return 4002 4003} 4004 4005// Serialize turns this object into an interface{}. 4006func (t *widthIntermediateType) Serialize() (i interface{}, err error) { 4007 if t.nonNegativeInteger != nil { 4008 i = nonNegativeIntegerSerialize(*t.nonNegativeInteger) 4009 return 4010 } 4011 if t.IRI != nil { 4012 i = IRISerialize(t.IRI) 4013 return 4014 } 4015 i = unknownValueSerialize(t.unknown_) 4016 return 4017} 4018 4019// partOfIntermediateType will only have one of its values set at most 4020type partOfIntermediateType struct { 4021 // An unknown value. 4022 unknown_ interface{} 4023 // Stores possible LinkType type for partOf property 4024 Link LinkType 4025 // Stores possible CollectionType type for partOf property 4026 Collection CollectionType 4027 // Stores possible *url.URL type for partOf property 4028 IRI *url.URL 4029} 4030 4031// Deserialize takes an interface{} and attempts to create a valid intermediate type. 4032func (t *partOfIntermediateType) Deserialize(i interface{}) (err error) { 4033 matched := false 4034 if m, ok := i.(map[string]interface{}); ok { 4035 if tv, ok := m["type"]; ok { 4036 var types []string 4037 if tvs, ok := tv.([]interface{}); ok { 4038 for _, tvi := range tvs { 4039 if typeString, ok := tvi.(string); ok { 4040 types = append(types, typeString) 4041 } 4042 } 4043 } else if typeString, ok := tv.(string); ok { 4044 types = append(types, typeString) 4045 } 4046 if !matched { 4047 for _, kind := range types { 4048 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 4049 err = t.Link.Deserialize(m) 4050 matched = true 4051 break 4052 } 4053 } 4054 } 4055 if !matched { 4056 for _, kind := range types { 4057 if t.Collection, ok = resolveObject(kind).(CollectionType); t.Collection != nil && ok { 4058 err = t.Collection.Deserialize(m) 4059 matched = true 4060 break 4061 } 4062 } 4063 } 4064 } else { 4065 t.unknown_ = m 4066 } 4067 } else if i != nil { 4068 if !matched { 4069 t.IRI, err = IRIDeserialize(i) 4070 if err != nil { 4071 t.IRI = nil 4072 } else { 4073 matched = true 4074 } 4075 } 4076 } 4077 if !matched { 4078 t.unknown_ = unknownValueDeserialize(i) 4079 } 4080 return 4081 4082} 4083 4084// Serialize turns this object into an interface{}. 4085func (t *partOfIntermediateType) Serialize() (i interface{}, err error) { 4086 if t.Link != nil { 4087 i, err = t.Link.Serialize() 4088 return 4089 } 4090 if t.Collection != nil { 4091 i, err = t.Collection.Serialize() 4092 return 4093 } 4094 if t.IRI != nil { 4095 i = IRISerialize(t.IRI) 4096 return 4097 } 4098 i = unknownValueSerialize(t.unknown_) 4099 return 4100} 4101 4102// imageIntermediateType will only have one of its values set at most 4103type imageIntermediateType struct { 4104 // An unknown value. 4105 unknown_ interface{} 4106 // Stores possible ImageType type for image property 4107 Image ImageType 4108 // Stores possible LinkType type for image property 4109 Link LinkType 4110 // Stores possible *url.URL type for image property 4111 IRI *url.URL 4112} 4113 4114// Deserialize takes an interface{} and attempts to create a valid intermediate type. 4115func (t *imageIntermediateType) Deserialize(i interface{}) (err error) { 4116 matched := false 4117 if m, ok := i.(map[string]interface{}); ok { 4118 if tv, ok := m["type"]; ok { 4119 var types []string 4120 if tvs, ok := tv.([]interface{}); ok { 4121 for _, tvi := range tvs { 4122 if typeString, ok := tvi.(string); ok { 4123 types = append(types, typeString) 4124 } 4125 } 4126 } else if typeString, ok := tv.(string); ok { 4127 types = append(types, typeString) 4128 } 4129 if !matched { 4130 for _, kind := range types { 4131 if t.Image, ok = resolveObject(kind).(ImageType); t.Image != nil && ok { 4132 err = t.Image.Deserialize(m) 4133 matched = true 4134 break 4135 } 4136 } 4137 } 4138 if !matched { 4139 for _, kind := range types { 4140 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 4141 err = t.Link.Deserialize(m) 4142 matched = true 4143 break 4144 } 4145 } 4146 } 4147 } else { 4148 t.unknown_ = m 4149 } 4150 } else if i != nil { 4151 if !matched { 4152 t.IRI, err = IRIDeserialize(i) 4153 if err != nil { 4154 t.IRI = nil 4155 } else { 4156 matched = true 4157 } 4158 } 4159 } 4160 if !matched { 4161 t.unknown_ = unknownValueDeserialize(i) 4162 } 4163 return 4164 4165} 4166 4167// Serialize turns this object into an interface{}. 4168func (t *imageIntermediateType) Serialize() (i interface{}, err error) { 4169 if t.Image != nil { 4170 i, err = t.Image.Serialize() 4171 return 4172 } 4173 if t.Link != nil { 4174 i, err = t.Link.Serialize() 4175 return 4176 } 4177 if t.IRI != nil { 4178 i = IRISerialize(t.IRI) 4179 return 4180 } 4181 i = unknownValueSerialize(t.unknown_) 4182 return 4183} 4184 4185// ccIntermediateType will only have one of its values set at most 4186type ccIntermediateType struct { 4187 // An unknown value. 4188 unknown_ interface{} 4189 // Stores possible ObjectType type for cc property 4190 Object ObjectType 4191 // Stores possible LinkType type for cc property 4192 Link LinkType 4193 // Stores possible *url.URL type for cc property 4194 IRI *url.URL 4195} 4196 4197// Deserialize takes an interface{} and attempts to create a valid intermediate type. 4198func (t *ccIntermediateType) Deserialize(i interface{}) (err error) { 4199 matched := false 4200 if m, ok := i.(map[string]interface{}); ok { 4201 if tv, ok := m["type"]; ok { 4202 var types []string 4203 if tvs, ok := tv.([]interface{}); ok { 4204 for _, tvi := range tvs { 4205 if typeString, ok := tvi.(string); ok { 4206 types = append(types, typeString) 4207 } 4208 } 4209 } else if typeString, ok := tv.(string); ok { 4210 types = append(types, typeString) 4211 } 4212 if !matched { 4213 for _, kind := range types { 4214 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 4215 err = t.Object.Deserialize(m) 4216 matched = true 4217 break 4218 } 4219 } 4220 } 4221 if !matched { 4222 for _, kind := range types { 4223 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 4224 err = t.Link.Deserialize(m) 4225 matched = true 4226 break 4227 } 4228 } 4229 } 4230 } else { 4231 t.unknown_ = m 4232 } 4233 } else if i != nil { 4234 if !matched { 4235 t.IRI, err = IRIDeserialize(i) 4236 if err != nil { 4237 t.IRI = nil 4238 } else { 4239 matched = true 4240 } 4241 } 4242 } 4243 if !matched { 4244 t.unknown_ = unknownValueDeserialize(i) 4245 } 4246 return 4247 4248} 4249 4250// Serialize turns this object into an interface{}. 4251func (t *ccIntermediateType) Serialize() (i interface{}, err error) { 4252 if t.Object != nil { 4253 i, err = t.Object.Serialize() 4254 return 4255 } 4256 if t.Link != nil { 4257 i, err = t.Link.Serialize() 4258 return 4259 } 4260 if t.IRI != nil { 4261 i = IRISerialize(t.IRI) 4262 return 4263 } 4264 i = unknownValueSerialize(t.unknown_) 4265 return 4266} 4267 4268// instrumentIntermediateType will only have one of its values set at most 4269type instrumentIntermediateType struct { 4270 // An unknown value. 4271 unknown_ interface{} 4272 // Stores possible ObjectType type for instrument property 4273 Object ObjectType 4274 // Stores possible LinkType type for instrument property 4275 Link LinkType 4276 // Stores possible *url.URL type for instrument property 4277 IRI *url.URL 4278} 4279 4280// Deserialize takes an interface{} and attempts to create a valid intermediate type. 4281func (t *instrumentIntermediateType) Deserialize(i interface{}) (err error) { 4282 matched := false 4283 if m, ok := i.(map[string]interface{}); ok { 4284 if tv, ok := m["type"]; ok { 4285 var types []string 4286 if tvs, ok := tv.([]interface{}); ok { 4287 for _, tvi := range tvs { 4288 if typeString, ok := tvi.(string); ok { 4289 types = append(types, typeString) 4290 } 4291 } 4292 } else if typeString, ok := tv.(string); ok { 4293 types = append(types, typeString) 4294 } 4295 if !matched { 4296 for _, kind := range types { 4297 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 4298 err = t.Object.Deserialize(m) 4299 matched = true 4300 break 4301 } 4302 } 4303 } 4304 if !matched { 4305 for _, kind := range types { 4306 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 4307 err = t.Link.Deserialize(m) 4308 matched = true 4309 break 4310 } 4311 } 4312 } 4313 } else { 4314 t.unknown_ = m 4315 } 4316 } else if i != nil { 4317 if !matched { 4318 t.IRI, err = IRIDeserialize(i) 4319 if err != nil { 4320 t.IRI = nil 4321 } else { 4322 matched = true 4323 } 4324 } 4325 } 4326 if !matched { 4327 t.unknown_ = unknownValueDeserialize(i) 4328 } 4329 return 4330 4331} 4332 4333// Serialize turns this object into an interface{}. 4334func (t *instrumentIntermediateType) Serialize() (i interface{}, err error) { 4335 if t.Object != nil { 4336 i, err = t.Object.Serialize() 4337 return 4338 } 4339 if t.Link != nil { 4340 i, err = t.Link.Serialize() 4341 return 4342 } 4343 if t.IRI != nil { 4344 i = IRISerialize(t.IRI) 4345 return 4346 } 4347 i = unknownValueSerialize(t.unknown_) 4348 return 4349} 4350 4351// lastIntermediateType will only have one of its values set at most 4352type lastIntermediateType struct { 4353 // An unknown value. 4354 unknown_ interface{} 4355 // Stores possible CollectionPageType type for last property 4356 CollectionPage CollectionPageType 4357 // Stores possible LinkType type for last property 4358 Link LinkType 4359 // Stores possible *url.URL type for last property 4360 IRI *url.URL 4361 // Stores possible OrderedCollectionPageType type for last property 4362 OrderedCollectionPage OrderedCollectionPageType 4363} 4364 4365// Deserialize takes an interface{} and attempts to create a valid intermediate type. 4366func (t *lastIntermediateType) Deserialize(i interface{}) (err error) { 4367 matched := false 4368 if m, ok := i.(map[string]interface{}); ok { 4369 if tv, ok := m["type"]; ok { 4370 var types []string 4371 if tvs, ok := tv.([]interface{}); ok { 4372 for _, tvi := range tvs { 4373 if typeString, ok := tvi.(string); ok { 4374 types = append(types, typeString) 4375 } 4376 } 4377 } else if typeString, ok := tv.(string); ok { 4378 types = append(types, typeString) 4379 } 4380 if !matched { 4381 for _, kind := range types { 4382 if t.CollectionPage, ok = resolveObject(kind).(CollectionPageType); t.CollectionPage != nil && ok { 4383 err = t.CollectionPage.Deserialize(m) 4384 matched = true 4385 break 4386 } 4387 } 4388 } 4389 if !matched { 4390 for _, kind := range types { 4391 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 4392 err = t.Link.Deserialize(m) 4393 matched = true 4394 break 4395 } 4396 } 4397 } 4398 if !matched { 4399 for _, kind := range types { 4400 if t.OrderedCollectionPage, ok = resolveObject(kind).(OrderedCollectionPageType); t.OrderedCollectionPage != nil && ok { 4401 err = t.OrderedCollectionPage.Deserialize(m) 4402 matched = true 4403 break 4404 } 4405 } 4406 } 4407 } else { 4408 t.unknown_ = m 4409 } 4410 } else if i != nil { 4411 if !matched { 4412 t.IRI, err = IRIDeserialize(i) 4413 if err != nil { 4414 t.IRI = nil 4415 } else { 4416 matched = true 4417 } 4418 } 4419 } 4420 if !matched { 4421 t.unknown_ = unknownValueDeserialize(i) 4422 } 4423 return 4424 4425} 4426 4427// Serialize turns this object into an interface{}. 4428func (t *lastIntermediateType) Serialize() (i interface{}, err error) { 4429 if t.CollectionPage != nil { 4430 i, err = t.CollectionPage.Serialize() 4431 return 4432 } 4433 if t.Link != nil { 4434 i, err = t.Link.Serialize() 4435 return 4436 } 4437 if t.IRI != nil { 4438 i = IRISerialize(t.IRI) 4439 return 4440 } 4441 if t.OrderedCollectionPage != nil { 4442 i, err = t.OrderedCollectionPage.Serialize() 4443 return 4444 } 4445 i = unknownValueSerialize(t.unknown_) 4446 return 4447} 4448 4449// audienceIntermediateType will only have one of its values set at most 4450type audienceIntermediateType struct { 4451 // An unknown value. 4452 unknown_ interface{} 4453 // Stores possible ObjectType type for audience property 4454 Object ObjectType 4455 // Stores possible LinkType type for audience property 4456 Link LinkType 4457 // Stores possible *url.URL type for audience property 4458 IRI *url.URL 4459} 4460 4461// Deserialize takes an interface{} and attempts to create a valid intermediate type. 4462func (t *audienceIntermediateType) Deserialize(i interface{}) (err error) { 4463 matched := false 4464 if m, ok := i.(map[string]interface{}); ok { 4465 if tv, ok := m["type"]; ok { 4466 var types []string 4467 if tvs, ok := tv.([]interface{}); ok { 4468 for _, tvi := range tvs { 4469 if typeString, ok := tvi.(string); ok { 4470 types = append(types, typeString) 4471 } 4472 } 4473 } else if typeString, ok := tv.(string); ok { 4474 types = append(types, typeString) 4475 } 4476 if !matched { 4477 for _, kind := range types { 4478 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 4479 err = t.Object.Deserialize(m) 4480 matched = true 4481 break 4482 } 4483 } 4484 } 4485 if !matched { 4486 for _, kind := range types { 4487 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 4488 err = t.Link.Deserialize(m) 4489 matched = true 4490 break 4491 } 4492 } 4493 } 4494 } else { 4495 t.unknown_ = m 4496 } 4497 } else if i != nil { 4498 if !matched { 4499 t.IRI, err = IRIDeserialize(i) 4500 if err != nil { 4501 t.IRI = nil 4502 } else { 4503 matched = true 4504 } 4505 } 4506 } 4507 if !matched { 4508 t.unknown_ = unknownValueDeserialize(i) 4509 } 4510 return 4511 4512} 4513 4514// Serialize turns this object into an interface{}. 4515func (t *audienceIntermediateType) Serialize() (i interface{}, err error) { 4516 if t.Object != nil { 4517 i, err = t.Object.Serialize() 4518 return 4519 } 4520 if t.Link != nil { 4521 i, err = t.Link.Serialize() 4522 return 4523 } 4524 if t.IRI != nil { 4525 i = IRISerialize(t.IRI) 4526 return 4527 } 4528 i = unknownValueSerialize(t.unknown_) 4529 return 4530} 4531 4532// durationIntermediateType will only have one of its values set at most 4533type durationIntermediateType struct { 4534 // An unknown value. 4535 unknown_ interface{} 4536 // Stores possible *time.Duration type for duration property 4537 duration *time.Duration 4538 // Stores possible *url.URL type for duration property 4539 IRI *url.URL 4540} 4541 4542// Deserialize takes an interface{} and attempts to create a valid intermediate type. 4543func (t *durationIntermediateType) Deserialize(i interface{}) (err error) { 4544 matched := false 4545 if m, ok := i.(map[string]interface{}); ok { 4546 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 4547 } else if i != nil { 4548 if !matched { 4549 t.duration, err = durationDeserialize(i) 4550 if err != nil { 4551 t.duration = nil 4552 } else { 4553 matched = true 4554 } 4555 } 4556 if !matched { 4557 t.IRI, err = IRIDeserialize(i) 4558 if err != nil { 4559 t.IRI = nil 4560 } else { 4561 matched = true 4562 } 4563 } 4564 } 4565 if !matched { 4566 t.unknown_ = unknownValueDeserialize(i) 4567 } 4568 return 4569 4570} 4571 4572// Serialize turns this object into an interface{}. 4573func (t *durationIntermediateType) Serialize() (i interface{}, err error) { 4574 if t.duration != nil { 4575 i = durationSerialize(*t.duration) 4576 return 4577 } 4578 if t.IRI != nil { 4579 i = IRISerialize(t.IRI) 4580 return 4581 } 4582 i = unknownValueSerialize(t.unknown_) 4583 return 4584} 4585 4586// targetIntermediateType will only have one of its values set at most 4587type targetIntermediateType struct { 4588 // An unknown value. 4589 unknown_ interface{} 4590 // Stores possible ObjectType type for target property 4591 Object ObjectType 4592 // Stores possible LinkType type for target property 4593 Link LinkType 4594 // Stores possible *url.URL type for target property 4595 IRI *url.URL 4596} 4597 4598// Deserialize takes an interface{} and attempts to create a valid intermediate type. 4599func (t *targetIntermediateType) Deserialize(i interface{}) (err error) { 4600 matched := false 4601 if m, ok := i.(map[string]interface{}); ok { 4602 if tv, ok := m["type"]; ok { 4603 var types []string 4604 if tvs, ok := tv.([]interface{}); ok { 4605 for _, tvi := range tvs { 4606 if typeString, ok := tvi.(string); ok { 4607 types = append(types, typeString) 4608 } 4609 } 4610 } else if typeString, ok := tv.(string); ok { 4611 types = append(types, typeString) 4612 } 4613 if !matched { 4614 for _, kind := range types { 4615 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 4616 err = t.Object.Deserialize(m) 4617 matched = true 4618 break 4619 } 4620 } 4621 } 4622 if !matched { 4623 for _, kind := range types { 4624 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 4625 err = t.Link.Deserialize(m) 4626 matched = true 4627 break 4628 } 4629 } 4630 } 4631 } else { 4632 t.unknown_ = m 4633 } 4634 } else if i != nil { 4635 if !matched { 4636 t.IRI, err = IRIDeserialize(i) 4637 if err != nil { 4638 t.IRI = nil 4639 } else { 4640 matched = true 4641 } 4642 } 4643 } 4644 if !matched { 4645 t.unknown_ = unknownValueDeserialize(i) 4646 } 4647 return 4648 4649} 4650 4651// Serialize turns this object into an interface{}. 4652func (t *targetIntermediateType) Serialize() (i interface{}, err error) { 4653 if t.Object != nil { 4654 i, err = t.Object.Serialize() 4655 return 4656 } 4657 if t.Link != nil { 4658 i, err = t.Link.Serialize() 4659 return 4660 } 4661 if t.IRI != nil { 4662 i = IRISerialize(t.IRI) 4663 return 4664 } 4665 i = unknownValueSerialize(t.unknown_) 4666 return 4667} 4668 4669// deletedIntermediateType will only have one of its values set at most 4670type deletedIntermediateType struct { 4671 // An unknown value. 4672 unknown_ interface{} 4673 // Stores possible *time.Time type for deleted property 4674 dateTime *time.Time 4675 // Stores possible *url.URL type for deleted property 4676 IRI *url.URL 4677} 4678 4679// Deserialize takes an interface{} and attempts to create a valid intermediate type. 4680func (t *deletedIntermediateType) Deserialize(i interface{}) (err error) { 4681 matched := false 4682 if m, ok := i.(map[string]interface{}); ok { 4683 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 4684 } else if i != nil { 4685 if !matched { 4686 t.dateTime, err = dateTimeDeserialize(i) 4687 if err != nil { 4688 t.dateTime = nil 4689 } else { 4690 matched = true 4691 } 4692 } 4693 if !matched { 4694 t.IRI, err = IRIDeserialize(i) 4695 if err != nil { 4696 t.IRI = nil 4697 } else { 4698 matched = true 4699 } 4700 } 4701 } 4702 if !matched { 4703 t.unknown_ = unknownValueDeserialize(i) 4704 } 4705 return 4706 4707} 4708 4709// Serialize turns this object into an interface{}. 4710func (t *deletedIntermediateType) Serialize() (i interface{}, err error) { 4711 if t.dateTime != nil { 4712 i = dateTimeSerialize(*t.dateTime) 4713 return 4714 } 4715 if t.IRI != nil { 4716 i = IRISerialize(t.IRI) 4717 return 4718 } 4719 i = unknownValueSerialize(t.unknown_) 4720 return 4721} 4722 4723// attributedToIntermediateType will only have one of its values set at most 4724type attributedToIntermediateType struct { 4725 // An unknown value. 4726 unknown_ interface{} 4727 // Stores possible ObjectType type for attributedTo property 4728 Object ObjectType 4729 // Stores possible LinkType type for attributedTo property 4730 Link LinkType 4731 // Stores possible *url.URL type for attributedTo property 4732 IRI *url.URL 4733} 4734 4735// Deserialize takes an interface{} and attempts to create a valid intermediate type. 4736func (t *attributedToIntermediateType) Deserialize(i interface{}) (err error) { 4737 matched := false 4738 if m, ok := i.(map[string]interface{}); ok { 4739 if tv, ok := m["type"]; ok { 4740 var types []string 4741 if tvs, ok := tv.([]interface{}); ok { 4742 for _, tvi := range tvs { 4743 if typeString, ok := tvi.(string); ok { 4744 types = append(types, typeString) 4745 } 4746 } 4747 } else if typeString, ok := tv.(string); ok { 4748 types = append(types, typeString) 4749 } 4750 if !matched { 4751 for _, kind := range types { 4752 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 4753 err = t.Object.Deserialize(m) 4754 matched = true 4755 break 4756 } 4757 } 4758 } 4759 if !matched { 4760 for _, kind := range types { 4761 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 4762 err = t.Link.Deserialize(m) 4763 matched = true 4764 break 4765 } 4766 } 4767 } 4768 } else { 4769 t.unknown_ = m 4770 } 4771 } else if i != nil { 4772 if !matched { 4773 t.IRI, err = IRIDeserialize(i) 4774 if err != nil { 4775 t.IRI = nil 4776 } else { 4777 matched = true 4778 } 4779 } 4780 } 4781 if !matched { 4782 t.unknown_ = unknownValueDeserialize(i) 4783 } 4784 return 4785 4786} 4787 4788// Serialize turns this object into an interface{}. 4789func (t *attributedToIntermediateType) Serialize() (i interface{}, err error) { 4790 if t.Object != nil { 4791 i, err = t.Object.Serialize() 4792 return 4793 } 4794 if t.Link != nil { 4795 i, err = t.Link.Serialize() 4796 return 4797 } 4798 if t.IRI != nil { 4799 i = IRISerialize(t.IRI) 4800 return 4801 } 4802 i = unknownValueSerialize(t.unknown_) 4803 return 4804} 4805 4806// summaryIntermediateType will only have one of its values set at most 4807type summaryIntermediateType struct { 4808 // An unknown value. 4809 unknown_ interface{} 4810 // Stores possible *string type for summary property 4811 stringName *string 4812 // Stores possible *string type for summary property 4813 langString *string 4814 // Stores possible *url.URL type for summary property 4815 IRI *url.URL 4816} 4817 4818// Deserialize takes an interface{} and attempts to create a valid intermediate type. 4819func (t *summaryIntermediateType) Deserialize(i interface{}) (err error) { 4820 matched := false 4821 if m, ok := i.(map[string]interface{}); ok { 4822 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 4823 } else if i != nil { 4824 if !matched { 4825 t.stringName, err = stringDeserialize(i) 4826 if err != nil { 4827 t.stringName = nil 4828 } else { 4829 matched = true 4830 } 4831 } 4832 if !matched { 4833 t.langString, err = langStringDeserialize(i) 4834 if err != nil { 4835 t.langString = nil 4836 } else { 4837 matched = true 4838 } 4839 } 4840 if !matched { 4841 t.IRI, err = IRIDeserialize(i) 4842 if err != nil { 4843 t.IRI = nil 4844 } else { 4845 matched = true 4846 } 4847 } 4848 } 4849 if !matched { 4850 t.unknown_ = unknownValueDeserialize(i) 4851 } 4852 return 4853 4854} 4855 4856// Serialize turns this object into an interface{}. 4857func (t *summaryIntermediateType) Serialize() (i interface{}, err error) { 4858 if t.stringName != nil { 4859 i = stringSerialize(*t.stringName) 4860 return 4861 } 4862 if t.langString != nil { 4863 i = langStringSerialize(*t.langString) 4864 return 4865 } 4866 if t.IRI != nil { 4867 i = IRISerialize(t.IRI) 4868 return 4869 } 4870 i = unknownValueSerialize(t.unknown_) 4871 return 4872} 4873 4874// endpointsIntermediateType will only have one of its values set at most 4875type endpointsIntermediateType struct { 4876 // An unknown value. 4877 unknown_ interface{} 4878 // Stores possible ObjectType type for endpoints property 4879 Object ObjectType 4880 // Stores possible *url.URL type for endpoints property 4881 IRI *url.URL 4882} 4883 4884// Deserialize takes an interface{} and attempts to create a valid intermediate type. 4885func (t *endpointsIntermediateType) Deserialize(i interface{}) (err error) { 4886 matched := false 4887 if m, ok := i.(map[string]interface{}); ok { 4888 if tv, ok := m["type"]; ok { 4889 var types []string 4890 if tvs, ok := tv.([]interface{}); ok { 4891 for _, tvi := range tvs { 4892 if typeString, ok := tvi.(string); ok { 4893 types = append(types, typeString) 4894 } 4895 } 4896 } else if typeString, ok := tv.(string); ok { 4897 types = append(types, typeString) 4898 } 4899 if !matched { 4900 for _, kind := range types { 4901 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 4902 err = t.Object.Deserialize(m) 4903 matched = true 4904 break 4905 } 4906 } 4907 } 4908 } else { 4909 t.unknown_ = m 4910 } 4911 } else if i != nil { 4912 if !matched { 4913 t.IRI, err = IRIDeserialize(i) 4914 if err != nil { 4915 t.IRI = nil 4916 } else { 4917 matched = true 4918 } 4919 } 4920 } 4921 if !matched { 4922 t.unknown_ = unknownValueDeserialize(i) 4923 } 4924 return 4925 4926} 4927 4928// Serialize turns this object into an interface{}. 4929func (t *endpointsIntermediateType) Serialize() (i interface{}, err error) { 4930 if t.Object != nil { 4931 i, err = t.Object.Serialize() 4932 return 4933 } 4934 if t.IRI != nil { 4935 i = IRISerialize(t.IRI) 4936 return 4937 } 4938 i = unknownValueSerialize(t.unknown_) 4939 return 4940} 4941 4942// heightIntermediateType will only have one of its values set at most 4943type heightIntermediateType struct { 4944 // An unknown value. 4945 unknown_ interface{} 4946 // Stores possible *int64 type for height property 4947 nonNegativeInteger *int64 4948 // Stores possible *url.URL type for height property 4949 IRI *url.URL 4950} 4951 4952// Deserialize takes an interface{} and attempts to create a valid intermediate type. 4953func (t *heightIntermediateType) Deserialize(i interface{}) (err error) { 4954 matched := false 4955 if m, ok := i.(map[string]interface{}); ok { 4956 err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m) 4957 } else if i != nil { 4958 if !matched { 4959 t.nonNegativeInteger, err = nonNegativeIntegerDeserialize(i) 4960 if err != nil { 4961 t.nonNegativeInteger = nil 4962 } else { 4963 matched = true 4964 } 4965 } 4966 if !matched { 4967 t.IRI, err = IRIDeserialize(i) 4968 if err != nil { 4969 t.IRI = nil 4970 } else { 4971 matched = true 4972 } 4973 } 4974 } 4975 if !matched { 4976 t.unknown_ = unknownValueDeserialize(i) 4977 } 4978 return 4979 4980} 4981 4982// Serialize turns this object into an interface{}. 4983func (t *heightIntermediateType) Serialize() (i interface{}, err error) { 4984 if t.nonNegativeInteger != nil { 4985 i = nonNegativeIntegerSerialize(*t.nonNegativeInteger) 4986 return 4987 } 4988 if t.IRI != nil { 4989 i = IRISerialize(t.IRI) 4990 return 4991 } 4992 i = unknownValueSerialize(t.unknown_) 4993 return 4994} 4995 4996// itemsIntermediateType will only have one of its values set at most 4997type itemsIntermediateType struct { 4998 // An unknown value. 4999 unknown_ interface{} 5000 // Stores possible ObjectType type for items property 5001 Object ObjectType 5002 // Stores possible LinkType type for items property 5003 Link LinkType 5004 // Stores possible *url.URL type for items property 5005 IRI *url.URL 5006} 5007 5008// Deserialize takes an interface{} and attempts to create a valid intermediate type. 5009func (t *itemsIntermediateType) Deserialize(i interface{}) (err error) { 5010 matched := false 5011 if m, ok := i.(map[string]interface{}); ok { 5012 if tv, ok := m["type"]; ok { 5013 var types []string 5014 if tvs, ok := tv.([]interface{}); ok { 5015 for _, tvi := range tvs { 5016 if typeString, ok := tvi.(string); ok { 5017 types = append(types, typeString) 5018 } 5019 } 5020 } else if typeString, ok := tv.(string); ok { 5021 types = append(types, typeString) 5022 } 5023 if !matched { 5024 for _, kind := range types { 5025 if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok { 5026 err = t.Object.Deserialize(m) 5027 matched = true 5028 break 5029 } 5030 } 5031 } 5032 if !matched { 5033 for _, kind := range types { 5034 if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok { 5035 err = t.Link.Deserialize(m) 5036 matched = true 5037 break 5038 } 5039 } 5040 } 5041 } else { 5042 t.unknown_ = m 5043 } 5044 } else if i != nil { 5045 if !matched { 5046 t.IRI, err = IRIDeserialize(i) 5047 if err != nil { 5048 t.IRI = nil 5049 } else { 5050 matched = true 5051 } 5052 } 5053 } 5054 if !matched { 5055 t.unknown_ = unknownValueDeserialize(i) 5056 } 5057 return 5058 5059} 5060 5061// Serialize turns this object into an interface{}. 5062func (t *itemsIntermediateType) Serialize() (i interface{}, err error) { 5063 if t.Object != nil { 5064 i, err = t.Object.Serialize() 5065 return 5066 } 5067 if t.Link != nil { 5068 i, err = t.Link.Serialize() 5069 return 5070 } 5071 if t.IRI != nil { 5072 i = IRISerialize(t.IRI) 5073 return 5074 } 5075 i = unknownValueSerialize(t.unknown_) 5076 return 5077} 5078 5079// deserializebccIntermediateType will accept a map to create a bccIntermediateType 5080func deserializeBccIntermediateType(in interface{}) (t *bccIntermediateType, err error) { 5081 tmp := &bccIntermediateType{} 5082 err = tmp.Deserialize(in) 5083 return tmp, err 5084 5085} 5086 5087// deserializeSlice bccIntermediateType will accept a slice to create a slice of bccIntermediateType 5088func deserializeSliceBccIntermediateType(in []interface{}) (t []*bccIntermediateType, err error) { 5089 for _, i := range in { 5090 tmp := &bccIntermediateType{} 5091 err = tmp.Deserialize(i) 5092 if err != nil { 5093 return 5094 } 5095 t = append(t, tmp) 5096 } 5097 return 5098 5099} 5100 5101// serializebccIntermediateType will accept a bccIntermediateType to create a map 5102func serializeBccIntermediateType(t *bccIntermediateType) (i interface{}, err error) { 5103 i, err = t.Serialize() 5104 return 5105 5106} 5107 5108// serializeSlicebccIntermediateType will accept a slice of bccIntermediateType to create a slice result 5109func serializeSliceBccIntermediateType(s []*bccIntermediateType) (out []interface{}, err error) { 5110 for _, t := range s { 5111 v, err := t.Serialize() 5112 if err != nil { 5113 return nil, err 5114 } 5115 out = append(out, v) 5116 } 5117 return 5118 5119} 5120 5121// deserializeoneOfIntermediateType will accept a map to create a oneOfIntermediateType 5122func deserializeOneOfIntermediateType(in interface{}) (t *oneOfIntermediateType, err error) { 5123 tmp := &oneOfIntermediateType{} 5124 err = tmp.Deserialize(in) 5125 return tmp, err 5126 5127} 5128 5129// deserializeSlice oneOfIntermediateType will accept a slice to create a slice of oneOfIntermediateType 5130func deserializeSliceOneOfIntermediateType(in []interface{}) (t []*oneOfIntermediateType, err error) { 5131 for _, i := range in { 5132 tmp := &oneOfIntermediateType{} 5133 err = tmp.Deserialize(i) 5134 if err != nil { 5135 return 5136 } 5137 t = append(t, tmp) 5138 } 5139 return 5140 5141} 5142 5143// serializeoneOfIntermediateType will accept a oneOfIntermediateType to create a map 5144func serializeOneOfIntermediateType(t *oneOfIntermediateType) (i interface{}, err error) { 5145 i, err = t.Serialize() 5146 return 5147 5148} 5149 5150// serializeSliceoneOfIntermediateType will accept a slice of oneOfIntermediateType to create a slice result 5151func serializeSliceOneOfIntermediateType(s []*oneOfIntermediateType) (out []interface{}, err error) { 5152 for _, t := range s { 5153 v, err := t.Serialize() 5154 if err != nil { 5155 return nil, err 5156 } 5157 out = append(out, v) 5158 } 5159 return 5160 5161} 5162 5163// deserializeclosedIntermediateType will accept a map to create a closedIntermediateType 5164func deserializeClosedIntermediateType(in interface{}) (t *closedIntermediateType, err error) { 5165 tmp := &closedIntermediateType{} 5166 err = tmp.Deserialize(in) 5167 return tmp, err 5168 5169} 5170 5171// deserializeSlice closedIntermediateType will accept a slice to create a slice of closedIntermediateType 5172func deserializeSliceClosedIntermediateType(in []interface{}) (t []*closedIntermediateType, err error) { 5173 for _, i := range in { 5174 tmp := &closedIntermediateType{} 5175 err = tmp.Deserialize(i) 5176 if err != nil { 5177 return 5178 } 5179 t = append(t, tmp) 5180 } 5181 return 5182 5183} 5184 5185// serializeclosedIntermediateType will accept a closedIntermediateType to create a map 5186func serializeClosedIntermediateType(t *closedIntermediateType) (i interface{}, err error) { 5187 i, err = t.Serialize() 5188 return 5189 5190} 5191 5192// serializeSliceclosedIntermediateType will accept a slice of closedIntermediateType to create a slice result 5193func serializeSliceClosedIntermediateType(s []*closedIntermediateType) (out []interface{}, err error) { 5194 for _, t := range s { 5195 v, err := t.Serialize() 5196 if err != nil { 5197 return nil, err 5198 } 5199 out = append(out, v) 5200 } 5201 return 5202 5203} 5204 5205// deserializelongitudeIntermediateType will accept a map to create a longitudeIntermediateType 5206func deserializeLongitudeIntermediateType(in interface{}) (t *longitudeIntermediateType, err error) { 5207 tmp := &longitudeIntermediateType{} 5208 err = tmp.Deserialize(in) 5209 return tmp, err 5210 5211} 5212 5213// deserializeSlice longitudeIntermediateType will accept a slice to create a slice of longitudeIntermediateType 5214func deserializeSliceLongitudeIntermediateType(in []interface{}) (t []*longitudeIntermediateType, err error) { 5215 for _, i := range in { 5216 tmp := &longitudeIntermediateType{} 5217 err = tmp.Deserialize(i) 5218 if err != nil { 5219 return 5220 } 5221 t = append(t, tmp) 5222 } 5223 return 5224 5225} 5226 5227// serializelongitudeIntermediateType will accept a longitudeIntermediateType to create a map 5228func serializeLongitudeIntermediateType(t *longitudeIntermediateType) (i interface{}, err error) { 5229 i, err = t.Serialize() 5230 return 5231 5232} 5233 5234// serializeSlicelongitudeIntermediateType will accept a slice of longitudeIntermediateType to create a slice result 5235func serializeSliceLongitudeIntermediateType(s []*longitudeIntermediateType) (out []interface{}, err error) { 5236 for _, t := range s { 5237 v, err := t.Serialize() 5238 if err != nil { 5239 return nil, err 5240 } 5241 out = append(out, v) 5242 } 5243 return 5244 5245} 5246 5247// deserializenameIntermediateType will accept a map to create a nameIntermediateType 5248func deserializeNameIntermediateType(in interface{}) (t *nameIntermediateType, err error) { 5249 tmp := &nameIntermediateType{} 5250 err = tmp.Deserialize(in) 5251 return tmp, err 5252 5253} 5254 5255// deserializeSlice nameIntermediateType will accept a slice to create a slice of nameIntermediateType 5256func deserializeSliceNameIntermediateType(in []interface{}) (t []*nameIntermediateType, err error) { 5257 for _, i := range in { 5258 tmp := &nameIntermediateType{} 5259 err = tmp.Deserialize(i) 5260 if err != nil { 5261 return 5262 } 5263 t = append(t, tmp) 5264 } 5265 return 5266 5267} 5268 5269// serializenameIntermediateType will accept a nameIntermediateType to create a map 5270func serializeNameIntermediateType(t *nameIntermediateType) (i interface{}, err error) { 5271 i, err = t.Serialize() 5272 return 5273 5274} 5275 5276// serializeSlicenameIntermediateType will accept a slice of nameIntermediateType to create a slice result 5277func serializeSliceNameIntermediateType(s []*nameIntermediateType) (out []interface{}, err error) { 5278 for _, t := range s { 5279 v, err := t.Serialize() 5280 if err != nil { 5281 return nil, err 5282 } 5283 out = append(out, v) 5284 } 5285 return 5286 5287} 5288 5289// deserializelikedIntermediateType will accept a map to create a likedIntermediateType 5290func deserializeLikedIntermediateType(in interface{}) (t *likedIntermediateType, err error) { 5291 tmp := &likedIntermediateType{} 5292 err = tmp.Deserialize(in) 5293 return tmp, err 5294 5295} 5296 5297// deserializeSlice likedIntermediateType will accept a slice to create a slice of likedIntermediateType 5298func deserializeSliceLikedIntermediateType(in []interface{}) (t []*likedIntermediateType, err error) { 5299 for _, i := range in { 5300 tmp := &likedIntermediateType{} 5301 err = tmp.Deserialize(i) 5302 if err != nil { 5303 return 5304 } 5305 t = append(t, tmp) 5306 } 5307 return 5308 5309} 5310 5311// serializelikedIntermediateType will accept a likedIntermediateType to create a map 5312func serializeLikedIntermediateType(t *likedIntermediateType) (i interface{}, err error) { 5313 i, err = t.Serialize() 5314 return 5315 5316} 5317 5318// serializeSlicelikedIntermediateType will accept a slice of likedIntermediateType to create a slice result 5319func serializeSliceLikedIntermediateType(s []*likedIntermediateType) (out []interface{}, err error) { 5320 for _, t := range s { 5321 v, err := t.Serialize() 5322 if err != nil { 5323 return nil, err 5324 } 5325 out = append(out, v) 5326 } 5327 return 5328 5329} 5330 5331// deserializeresultIntermediateType will accept a map to create a resultIntermediateType 5332func deserializeResultIntermediateType(in interface{}) (t *resultIntermediateType, err error) { 5333 tmp := &resultIntermediateType{} 5334 err = tmp.Deserialize(in) 5335 return tmp, err 5336 5337} 5338 5339// deserializeSlice resultIntermediateType will accept a slice to create a slice of resultIntermediateType 5340func deserializeSliceResultIntermediateType(in []interface{}) (t []*resultIntermediateType, err error) { 5341 for _, i := range in { 5342 tmp := &resultIntermediateType{} 5343 err = tmp.Deserialize(i) 5344 if err != nil { 5345 return 5346 } 5347 t = append(t, tmp) 5348 } 5349 return 5350 5351} 5352 5353// serializeresultIntermediateType will accept a resultIntermediateType to create a map 5354func serializeResultIntermediateType(t *resultIntermediateType) (i interface{}, err error) { 5355 i, err = t.Serialize() 5356 return 5357 5358} 5359 5360// serializeSliceresultIntermediateType will accept a slice of resultIntermediateType to create a slice result 5361func serializeSliceResultIntermediateType(s []*resultIntermediateType) (out []interface{}, err error) { 5362 for _, t := range s { 5363 v, err := t.Serialize() 5364 if err != nil { 5365 return nil, err 5366 } 5367 out = append(out, v) 5368 } 5369 return 5370 5371} 5372 5373// deserializeanyOfIntermediateType will accept a map to create a anyOfIntermediateType 5374func deserializeAnyOfIntermediateType(in interface{}) (t *anyOfIntermediateType, err error) { 5375 tmp := &anyOfIntermediateType{} 5376 err = tmp.Deserialize(in) 5377 return tmp, err 5378 5379} 5380 5381// deserializeSlice anyOfIntermediateType will accept a slice to create a slice of anyOfIntermediateType 5382func deserializeSliceAnyOfIntermediateType(in []interface{}) (t []*anyOfIntermediateType, err error) { 5383 for _, i := range in { 5384 tmp := &anyOfIntermediateType{} 5385 err = tmp.Deserialize(i) 5386 if err != nil { 5387 return 5388 } 5389 t = append(t, tmp) 5390 } 5391 return 5392 5393} 5394 5395// serializeanyOfIntermediateType will accept a anyOfIntermediateType to create a map 5396func serializeAnyOfIntermediateType(t *anyOfIntermediateType) (i interface{}, err error) { 5397 i, err = t.Serialize() 5398 return 5399 5400} 5401 5402// serializeSliceanyOfIntermediateType will accept a slice of anyOfIntermediateType to create a slice result 5403func serializeSliceAnyOfIntermediateType(s []*anyOfIntermediateType) (out []interface{}, err error) { 5404 for _, t := range s { 5405 v, err := t.Serialize() 5406 if err != nil { 5407 return nil, err 5408 } 5409 out = append(out, v) 5410 } 5411 return 5412 5413} 5414 5415// deserializegeneratorIntermediateType will accept a map to create a generatorIntermediateType 5416func deserializeGeneratorIntermediateType(in interface{}) (t *generatorIntermediateType, err error) { 5417 tmp := &generatorIntermediateType{} 5418 err = tmp.Deserialize(in) 5419 return tmp, err 5420 5421} 5422 5423// deserializeSlice generatorIntermediateType will accept a slice to create a slice of generatorIntermediateType 5424func deserializeSliceGeneratorIntermediateType(in []interface{}) (t []*generatorIntermediateType, err error) { 5425 for _, i := range in { 5426 tmp := &generatorIntermediateType{} 5427 err = tmp.Deserialize(i) 5428 if err != nil { 5429 return 5430 } 5431 t = append(t, tmp) 5432 } 5433 return 5434 5435} 5436 5437// serializegeneratorIntermediateType will accept a generatorIntermediateType to create a map 5438func serializeGeneratorIntermediateType(t *generatorIntermediateType) (i interface{}, err error) { 5439 i, err = t.Serialize() 5440 return 5441 5442} 5443 5444// serializeSlicegeneratorIntermediateType will accept a slice of generatorIntermediateType to create a slice result 5445func serializeSliceGeneratorIntermediateType(s []*generatorIntermediateType) (out []interface{}, err error) { 5446 for _, t := range s { 5447 v, err := t.Serialize() 5448 if err != nil { 5449 return nil, err 5450 } 5451 out = append(out, v) 5452 } 5453 return 5454 5455} 5456 5457// deserializetoIntermediateType will accept a map to create a toIntermediateType 5458func deserializeToIntermediateType(in interface{}) (t *toIntermediateType, err error) { 5459 tmp := &toIntermediateType{} 5460 err = tmp.Deserialize(in) 5461 return tmp, err 5462 5463} 5464 5465// deserializeSlice toIntermediateType will accept a slice to create a slice of toIntermediateType 5466func deserializeSliceToIntermediateType(in []interface{}) (t []*toIntermediateType, err error) { 5467 for _, i := range in { 5468 tmp := &toIntermediateType{} 5469 err = tmp.Deserialize(i) 5470 if err != nil { 5471 return 5472 } 5473 t = append(t, tmp) 5474 } 5475 return 5476 5477} 5478 5479// serializetoIntermediateType will accept a toIntermediateType to create a map 5480func serializeToIntermediateType(t *toIntermediateType) (i interface{}, err error) { 5481 i, err = t.Serialize() 5482 return 5483 5484} 5485 5486// serializeSlicetoIntermediateType will accept a slice of toIntermediateType to create a slice result 5487func serializeSliceToIntermediateType(s []*toIntermediateType) (out []interface{}, err error) { 5488 for _, t := range s { 5489 v, err := t.Serialize() 5490 if err != nil { 5491 return nil, err 5492 } 5493 out = append(out, v) 5494 } 5495 return 5496 5497} 5498 5499// deserializefollowersIntermediateType will accept a map to create a followersIntermediateType 5500func deserializeFollowersIntermediateType(in interface{}) (t *followersIntermediateType, err error) { 5501 tmp := &followersIntermediateType{} 5502 err = tmp.Deserialize(in) 5503 return tmp, err 5504 5505} 5506 5507// deserializeSlice followersIntermediateType will accept a slice to create a slice of followersIntermediateType 5508func deserializeSliceFollowersIntermediateType(in []interface{}) (t []*followersIntermediateType, err error) { 5509 for _, i := range in { 5510 tmp := &followersIntermediateType{} 5511 err = tmp.Deserialize(i) 5512 if err != nil { 5513 return 5514 } 5515 t = append(t, tmp) 5516 } 5517 return 5518 5519} 5520 5521// serializefollowersIntermediateType will accept a followersIntermediateType to create a map 5522func serializeFollowersIntermediateType(t *followersIntermediateType) (i interface{}, err error) { 5523 i, err = t.Serialize() 5524 return 5525 5526} 5527 5528// serializeSlicefollowersIntermediateType will accept a slice of followersIntermediateType to create a slice result 5529func serializeSliceFollowersIntermediateType(s []*followersIntermediateType) (out []interface{}, err error) { 5530 for _, t := range s { 5531 v, err := t.Serialize() 5532 if err != nil { 5533 return nil, err 5534 } 5535 out = append(out, v) 5536 } 5537 return 5538 5539} 5540 5541// deserializelikesIntermediateType will accept a map to create a likesIntermediateType 5542func deserializeLikesIntermediateType(in interface{}) (t *likesIntermediateType, err error) { 5543 tmp := &likesIntermediateType{} 5544 err = tmp.Deserialize(in) 5545 return tmp, err 5546 5547} 5548 5549// deserializeSlice likesIntermediateType will accept a slice to create a slice of likesIntermediateType 5550func deserializeSliceLikesIntermediateType(in []interface{}) (t []*likesIntermediateType, err error) { 5551 for _, i := range in { 5552 tmp := &likesIntermediateType{} 5553 err = tmp.Deserialize(i) 5554 if err != nil { 5555 return 5556 } 5557 t = append(t, tmp) 5558 } 5559 return 5560 5561} 5562 5563// serializelikesIntermediateType will accept a likesIntermediateType to create a map 5564func serializeLikesIntermediateType(t *likesIntermediateType) (i interface{}, err error) { 5565 i, err = t.Serialize() 5566 return 5567 5568} 5569 5570// serializeSlicelikesIntermediateType will accept a slice of likesIntermediateType to create a slice result 5571func serializeSliceLikesIntermediateType(s []*likesIntermediateType) (out []interface{}, err error) { 5572 for _, t := range s { 5573 v, err := t.Serialize() 5574 if err != nil { 5575 return nil, err 5576 } 5577 out = append(out, v) 5578 } 5579 return 5580 5581} 5582 5583// deserializecontentIntermediateType will accept a map to create a contentIntermediateType 5584func deserializeContentIntermediateType(in interface{}) (t *contentIntermediateType, err error) { 5585 tmp := &contentIntermediateType{} 5586 err = tmp.Deserialize(in) 5587 return tmp, err 5588 5589} 5590 5591// deserializeSlice contentIntermediateType will accept a slice to create a slice of contentIntermediateType 5592func deserializeSliceContentIntermediateType(in []interface{}) (t []*contentIntermediateType, err error) { 5593 for _, i := range in { 5594 tmp := &contentIntermediateType{} 5595 err = tmp.Deserialize(i) 5596 if err != nil { 5597 return 5598 } 5599 t = append(t, tmp) 5600 } 5601 return 5602 5603} 5604 5605// serializecontentIntermediateType will accept a contentIntermediateType to create a map 5606func serializeContentIntermediateType(t *contentIntermediateType) (i interface{}, err error) { 5607 i, err = t.Serialize() 5608 return 5609 5610} 5611 5612// serializeSlicecontentIntermediateType will accept a slice of contentIntermediateType to create a slice result 5613func serializeSliceContentIntermediateType(s []*contentIntermediateType) (out []interface{}, err error) { 5614 for _, t := range s { 5615 v, err := t.Serialize() 5616 if err != nil { 5617 return nil, err 5618 } 5619 out = append(out, v) 5620 } 5621 return 5622 5623} 5624 5625// deserializestartTimeIntermediateType will accept a map to create a startTimeIntermediateType 5626func deserializeStartTimeIntermediateType(in interface{}) (t *startTimeIntermediateType, err error) { 5627 tmp := &startTimeIntermediateType{} 5628 err = tmp.Deserialize(in) 5629 return tmp, err 5630 5631} 5632 5633// deserializeSlice startTimeIntermediateType will accept a slice to create a slice of startTimeIntermediateType 5634func deserializeSliceStartTimeIntermediateType(in []interface{}) (t []*startTimeIntermediateType, err error) { 5635 for _, i := range in { 5636 tmp := &startTimeIntermediateType{} 5637 err = tmp.Deserialize(i) 5638 if err != nil { 5639 return 5640 } 5641 t = append(t, tmp) 5642 } 5643 return 5644 5645} 5646 5647// serializestartTimeIntermediateType will accept a startTimeIntermediateType to create a map 5648func serializeStartTimeIntermediateType(t *startTimeIntermediateType) (i interface{}, err error) { 5649 i, err = t.Serialize() 5650 return 5651 5652} 5653 5654// serializeSlicestartTimeIntermediateType will accept a slice of startTimeIntermediateType to create a slice result 5655func serializeSliceStartTimeIntermediateType(s []*startTimeIntermediateType) (out []interface{}, err error) { 5656 for _, t := range s { 5657 v, err := t.Serialize() 5658 if err != nil { 5659 return nil, err 5660 } 5661 out = append(out, v) 5662 } 5663 return 5664 5665} 5666 5667// deserializeinboxIntermediateType will accept a map to create a inboxIntermediateType 5668func deserializeInboxIntermediateType(in interface{}) (t *inboxIntermediateType, err error) { 5669 tmp := &inboxIntermediateType{} 5670 err = tmp.Deserialize(in) 5671 return tmp, err 5672 5673} 5674 5675// deserializeSlice inboxIntermediateType will accept a slice to create a slice of inboxIntermediateType 5676func deserializeSliceInboxIntermediateType(in []interface{}) (t []*inboxIntermediateType, err error) { 5677 for _, i := range in { 5678 tmp := &inboxIntermediateType{} 5679 err = tmp.Deserialize(i) 5680 if err != nil { 5681 return 5682 } 5683 t = append(t, tmp) 5684 } 5685 return 5686 5687} 5688 5689// serializeinboxIntermediateType will accept a inboxIntermediateType to create a map 5690func serializeInboxIntermediateType(t *inboxIntermediateType) (i interface{}, err error) { 5691 i, err = t.Serialize() 5692 return 5693 5694} 5695 5696// serializeSliceinboxIntermediateType will accept a slice of inboxIntermediateType to create a slice result 5697func serializeSliceInboxIntermediateType(s []*inboxIntermediateType) (out []interface{}, err error) { 5698 for _, t := range s { 5699 v, err := t.Serialize() 5700 if err != nil { 5701 return nil, err 5702 } 5703 out = append(out, v) 5704 } 5705 return 5706 5707} 5708 5709// deserializepreviewIntermediateType will accept a map to create a previewIntermediateType 5710func deserializePreviewIntermediateType(in interface{}) (t *previewIntermediateType, err error) { 5711 tmp := &previewIntermediateType{} 5712 err = tmp.Deserialize(in) 5713 return tmp, err 5714 5715} 5716 5717// deserializeSlice previewIntermediateType will accept a slice to create a slice of previewIntermediateType 5718func deserializeSlicePreviewIntermediateType(in []interface{}) (t []*previewIntermediateType, err error) { 5719 for _, i := range in { 5720 tmp := &previewIntermediateType{} 5721 err = tmp.Deserialize(i) 5722 if err != nil { 5723 return 5724 } 5725 t = append(t, tmp) 5726 } 5727 return 5728 5729} 5730 5731// serializepreviewIntermediateType will accept a previewIntermediateType to create a map 5732func serializePreviewIntermediateType(t *previewIntermediateType) (i interface{}, err error) { 5733 i, err = t.Serialize() 5734 return 5735 5736} 5737 5738// serializeSlicepreviewIntermediateType will accept a slice of previewIntermediateType to create a slice result 5739func serializeSlicePreviewIntermediateType(s []*previewIntermediateType) (out []interface{}, err error) { 5740 for _, t := range s { 5741 v, err := t.Serialize() 5742 if err != nil { 5743 return nil, err 5744 } 5745 out = append(out, v) 5746 } 5747 return 5748 5749} 5750 5751// deserializehreflangIntermediateType will accept a map to create a hreflangIntermediateType 5752func deserializeHreflangIntermediateType(in interface{}) (t *hreflangIntermediateType, err error) { 5753 tmp := &hreflangIntermediateType{} 5754 err = tmp.Deserialize(in) 5755 return tmp, err 5756 5757} 5758 5759// deserializeSlice hreflangIntermediateType will accept a slice to create a slice of hreflangIntermediateType 5760func deserializeSliceHreflangIntermediateType(in []interface{}) (t []*hreflangIntermediateType, err error) { 5761 for _, i := range in { 5762 tmp := &hreflangIntermediateType{} 5763 err = tmp.Deserialize(i) 5764 if err != nil { 5765 return 5766 } 5767 t = append(t, tmp) 5768 } 5769 return 5770 5771} 5772 5773// serializehreflangIntermediateType will accept a hreflangIntermediateType to create a map 5774func serializeHreflangIntermediateType(t *hreflangIntermediateType) (i interface{}, err error) { 5775 i, err = t.Serialize() 5776 return 5777 5778} 5779 5780// serializeSlicehreflangIntermediateType will accept a slice of hreflangIntermediateType to create a slice result 5781func serializeSliceHreflangIntermediateType(s []*hreflangIntermediateType) (out []interface{}, err error) { 5782 for _, t := range s { 5783 v, err := t.Serialize() 5784 if err != nil { 5785 return nil, err 5786 } 5787 out = append(out, v) 5788 } 5789 return 5790 5791} 5792 5793// deserializelatitudeIntermediateType will accept a map to create a latitudeIntermediateType 5794func deserializeLatitudeIntermediateType(in interface{}) (t *latitudeIntermediateType, err error) { 5795 tmp := &latitudeIntermediateType{} 5796 err = tmp.Deserialize(in) 5797 return tmp, err 5798 5799} 5800 5801// deserializeSlice latitudeIntermediateType will accept a slice to create a slice of latitudeIntermediateType 5802func deserializeSliceLatitudeIntermediateType(in []interface{}) (t []*latitudeIntermediateType, err error) { 5803 for _, i := range in { 5804 tmp := &latitudeIntermediateType{} 5805 err = tmp.Deserialize(i) 5806 if err != nil { 5807 return 5808 } 5809 t = append(t, tmp) 5810 } 5811 return 5812 5813} 5814 5815// serializelatitudeIntermediateType will accept a latitudeIntermediateType to create a map 5816func serializeLatitudeIntermediateType(t *latitudeIntermediateType) (i interface{}, err error) { 5817 i, err = t.Serialize() 5818 return 5819 5820} 5821 5822// serializeSlicelatitudeIntermediateType will accept a slice of latitudeIntermediateType to create a slice result 5823func serializeSliceLatitudeIntermediateType(s []*latitudeIntermediateType) (out []interface{}, err error) { 5824 for _, t := range s { 5825 v, err := t.Serialize() 5826 if err != nil { 5827 return nil, err 5828 } 5829 out = append(out, v) 5830 } 5831 return 5832 5833} 5834 5835// deserializedescribesIntermediateType will accept a map to create a describesIntermediateType 5836func deserializeDescribesIntermediateType(in interface{}) (t *describesIntermediateType, err error) { 5837 tmp := &describesIntermediateType{} 5838 err = tmp.Deserialize(in) 5839 return tmp, err 5840 5841} 5842 5843// deserializeSlice describesIntermediateType will accept a slice to create a slice of describesIntermediateType 5844func deserializeSliceDescribesIntermediateType(in []interface{}) (t []*describesIntermediateType, err error) { 5845 for _, i := range in { 5846 tmp := &describesIntermediateType{} 5847 err = tmp.Deserialize(i) 5848 if err != nil { 5849 return 5850 } 5851 t = append(t, tmp) 5852 } 5853 return 5854 5855} 5856 5857// serializedescribesIntermediateType will accept a describesIntermediateType to create a map 5858func serializeDescribesIntermediateType(t *describesIntermediateType) (i interface{}, err error) { 5859 i, err = t.Serialize() 5860 return 5861 5862} 5863 5864// serializeSlicedescribesIntermediateType will accept a slice of describesIntermediateType to create a slice result 5865func serializeSliceDescribesIntermediateType(s []*describesIntermediateType) (out []interface{}, err error) { 5866 for _, t := range s { 5867 v, err := t.Serialize() 5868 if err != nil { 5869 return nil, err 5870 } 5871 out = append(out, v) 5872 } 5873 return 5874 5875} 5876 5877// deserializelocationIntermediateType will accept a map to create a locationIntermediateType 5878func deserializeLocationIntermediateType(in interface{}) (t *locationIntermediateType, err error) { 5879 tmp := &locationIntermediateType{} 5880 err = tmp.Deserialize(in) 5881 return tmp, err 5882 5883} 5884 5885// deserializeSlice locationIntermediateType will accept a slice to create a slice of locationIntermediateType 5886func deserializeSliceLocationIntermediateType(in []interface{}) (t []*locationIntermediateType, err error) { 5887 for _, i := range in { 5888 tmp := &locationIntermediateType{} 5889 err = tmp.Deserialize(i) 5890 if err != nil { 5891 return 5892 } 5893 t = append(t, tmp) 5894 } 5895 return 5896 5897} 5898 5899// serializelocationIntermediateType will accept a locationIntermediateType to create a map 5900func serializeLocationIntermediateType(t *locationIntermediateType) (i interface{}, err error) { 5901 i, err = t.Serialize() 5902 return 5903 5904} 5905 5906// serializeSlicelocationIntermediateType will accept a slice of locationIntermediateType to create a slice result 5907func serializeSliceLocationIntermediateType(s []*locationIntermediateType) (out []interface{}, err error) { 5908 for _, t := range s { 5909 v, err := t.Serialize() 5910 if err != nil { 5911 return nil, err 5912 } 5913 out = append(out, v) 5914 } 5915 return 5916 5917} 5918 5919// deserializetagIntermediateType will accept a map to create a tagIntermediateType 5920func deserializeTagIntermediateType(in interface{}) (t *tagIntermediateType, err error) { 5921 tmp := &tagIntermediateType{} 5922 err = tmp.Deserialize(in) 5923 return tmp, err 5924 5925} 5926 5927// deserializeSlice tagIntermediateType will accept a slice to create a slice of tagIntermediateType 5928func deserializeSliceTagIntermediateType(in []interface{}) (t []*tagIntermediateType, err error) { 5929 for _, i := range in { 5930 tmp := &tagIntermediateType{} 5931 err = tmp.Deserialize(i) 5932 if err != nil { 5933 return 5934 } 5935 t = append(t, tmp) 5936 } 5937 return 5938 5939} 5940 5941// serializetagIntermediateType will accept a tagIntermediateType to create a map 5942func serializeTagIntermediateType(t *tagIntermediateType) (i interface{}, err error) { 5943 i, err = t.Serialize() 5944 return 5945 5946} 5947 5948// serializeSlicetagIntermediateType will accept a slice of tagIntermediateType to create a slice result 5949func serializeSliceTagIntermediateType(s []*tagIntermediateType) (out []interface{}, err error) { 5950 for _, t := range s { 5951 v, err := t.Serialize() 5952 if err != nil { 5953 return nil, err 5954 } 5955 out = append(out, v) 5956 } 5957 return 5958 5959} 5960 5961// deserializesourceIntermediateType will accept a map to create a sourceIntermediateType 5962func deserializeSourceIntermediateType(in interface{}) (t *sourceIntermediateType, err error) { 5963 tmp := &sourceIntermediateType{} 5964 err = tmp.Deserialize(in) 5965 return tmp, err 5966 5967} 5968 5969// deserializeSlice sourceIntermediateType will accept a slice to create a slice of sourceIntermediateType 5970func deserializeSliceSourceIntermediateType(in []interface{}) (t []*sourceIntermediateType, err error) { 5971 for _, i := range in { 5972 tmp := &sourceIntermediateType{} 5973 err = tmp.Deserialize(i) 5974 if err != nil { 5975 return 5976 } 5977 t = append(t, tmp) 5978 } 5979 return 5980 5981} 5982 5983// serializesourceIntermediateType will accept a sourceIntermediateType to create a map 5984func serializeSourceIntermediateType(t *sourceIntermediateType) (i interface{}, err error) { 5985 i, err = t.Serialize() 5986 return 5987 5988} 5989 5990// serializeSlicesourceIntermediateType will accept a slice of sourceIntermediateType to create a slice result 5991func serializeSliceSourceIntermediateType(s []*sourceIntermediateType) (out []interface{}, err error) { 5992 for _, t := range s { 5993 v, err := t.Serialize() 5994 if err != nil { 5995 return nil, err 5996 } 5997 out = append(out, v) 5998 } 5999 return 6000 6001} 6002 6003// deserializesubjectIntermediateType will accept a map to create a subjectIntermediateType 6004func deserializeSubjectIntermediateType(in interface{}) (t *subjectIntermediateType, err error) { 6005 tmp := &subjectIntermediateType{} 6006 err = tmp.Deserialize(in) 6007 return tmp, err 6008 6009} 6010 6011// deserializeSlice subjectIntermediateType will accept a slice to create a slice of subjectIntermediateType 6012func deserializeSliceSubjectIntermediateType(in []interface{}) (t []*subjectIntermediateType, err error) { 6013 for _, i := range in { 6014 tmp := &subjectIntermediateType{} 6015 err = tmp.Deserialize(i) 6016 if err != nil { 6017 return 6018 } 6019 t = append(t, tmp) 6020 } 6021 return 6022 6023} 6024 6025// serializesubjectIntermediateType will accept a subjectIntermediateType to create a map 6026func serializeSubjectIntermediateType(t *subjectIntermediateType) (i interface{}, err error) { 6027 i, err = t.Serialize() 6028 return 6029 6030} 6031 6032// serializeSlicesubjectIntermediateType will accept a slice of subjectIntermediateType to create a slice result 6033func serializeSliceSubjectIntermediateType(s []*subjectIntermediateType) (out []interface{}, err error) { 6034 for _, t := range s { 6035 v, err := t.Serialize() 6036 if err != nil { 6037 return nil, err 6038 } 6039 out = append(out, v) 6040 } 6041 return 6042 6043} 6044 6045// deserializepreferredUsernameIntermediateType will accept a map to create a preferredUsernameIntermediateType 6046func deserializePreferredUsernameIntermediateType(in interface{}) (t *preferredUsernameIntermediateType, err error) { 6047 tmp := &preferredUsernameIntermediateType{} 6048 err = tmp.Deserialize(in) 6049 return tmp, err 6050 6051} 6052 6053// deserializeSlice preferredUsernameIntermediateType will accept a slice to create a slice of preferredUsernameIntermediateType 6054func deserializeSlicePreferredUsernameIntermediateType(in []interface{}) (t []*preferredUsernameIntermediateType, err error) { 6055 for _, i := range in { 6056 tmp := &preferredUsernameIntermediateType{} 6057 err = tmp.Deserialize(i) 6058 if err != nil { 6059 return 6060 } 6061 t = append(t, tmp) 6062 } 6063 return 6064 6065} 6066 6067// serializepreferredUsernameIntermediateType will accept a preferredUsernameIntermediateType to create a map 6068func serializePreferredUsernameIntermediateType(t *preferredUsernameIntermediateType) (i interface{}, err error) { 6069 i, err = t.Serialize() 6070 return 6071 6072} 6073 6074// serializeSlicepreferredUsernameIntermediateType will accept a slice of preferredUsernameIntermediateType to create a slice result 6075func serializeSlicePreferredUsernameIntermediateType(s []*preferredUsernameIntermediateType) (out []interface{}, err error) { 6076 for _, t := range s { 6077 v, err := t.Serialize() 6078 if err != nil { 6079 return nil, err 6080 } 6081 out = append(out, v) 6082 } 6083 return 6084 6085} 6086 6087// deserializeunitsIntermediateType will accept a map to create a unitsIntermediateType 6088func deserializeUnitsIntermediateType(in interface{}) (t *unitsIntermediateType, err error) { 6089 tmp := &unitsIntermediateType{} 6090 err = tmp.Deserialize(in) 6091 return tmp, err 6092 6093} 6094 6095// deserializeSlice unitsIntermediateType will accept a slice to create a slice of unitsIntermediateType 6096func deserializeSliceUnitsIntermediateType(in []interface{}) (t []*unitsIntermediateType, err error) { 6097 for _, i := range in { 6098 tmp := &unitsIntermediateType{} 6099 err = tmp.Deserialize(i) 6100 if err != nil { 6101 return 6102 } 6103 t = append(t, tmp) 6104 } 6105 return 6106 6107} 6108 6109// serializeunitsIntermediateType will accept a unitsIntermediateType to create a map 6110func serializeUnitsIntermediateType(t *unitsIntermediateType) (i interface{}, err error) { 6111 i, err = t.Serialize() 6112 return 6113 6114} 6115 6116// serializeSliceunitsIntermediateType will accept a slice of unitsIntermediateType to create a slice result 6117func serializeSliceUnitsIntermediateType(s []*unitsIntermediateType) (out []interface{}, err error) { 6118 for _, t := range s { 6119 v, err := t.Serialize() 6120 if err != nil { 6121 return nil, err 6122 } 6123 out = append(out, v) 6124 } 6125 return 6126 6127} 6128 6129// deserializealtitudeIntermediateType will accept a map to create a altitudeIntermediateType 6130func deserializeAltitudeIntermediateType(in interface{}) (t *altitudeIntermediateType, err error) { 6131 tmp := &altitudeIntermediateType{} 6132 err = tmp.Deserialize(in) 6133 return tmp, err 6134 6135} 6136 6137// deserializeSlice altitudeIntermediateType will accept a slice to create a slice of altitudeIntermediateType 6138func deserializeSliceAltitudeIntermediateType(in []interface{}) (t []*altitudeIntermediateType, err error) { 6139 for _, i := range in { 6140 tmp := &altitudeIntermediateType{} 6141 err = tmp.Deserialize(i) 6142 if err != nil { 6143 return 6144 } 6145 t = append(t, tmp) 6146 } 6147 return 6148 6149} 6150 6151// serializealtitudeIntermediateType will accept a altitudeIntermediateType to create a map 6152func serializeAltitudeIntermediateType(t *altitudeIntermediateType) (i interface{}, err error) { 6153 i, err = t.Serialize() 6154 return 6155 6156} 6157 6158// serializeSlicealtitudeIntermediateType will accept a slice of altitudeIntermediateType to create a slice result 6159func serializeSliceAltitudeIntermediateType(s []*altitudeIntermediateType) (out []interface{}, err error) { 6160 for _, t := range s { 6161 v, err := t.Serialize() 6162 if err != nil { 6163 return nil, err 6164 } 6165 out = append(out, v) 6166 } 6167 return 6168 6169} 6170 6171// deserializeattachmentIntermediateType will accept a map to create a attachmentIntermediateType 6172func deserializeAttachmentIntermediateType(in interface{}) (t *attachmentIntermediateType, err error) { 6173 tmp := &attachmentIntermediateType{} 6174 err = tmp.Deserialize(in) 6175 return tmp, err 6176 6177} 6178 6179// deserializeSlice attachmentIntermediateType will accept a slice to create a slice of attachmentIntermediateType 6180func deserializeSliceAttachmentIntermediateType(in []interface{}) (t []*attachmentIntermediateType, err error) { 6181 for _, i := range in { 6182 tmp := &attachmentIntermediateType{} 6183 err = tmp.Deserialize(i) 6184 if err != nil { 6185 return 6186 } 6187 t = append(t, tmp) 6188 } 6189 return 6190 6191} 6192 6193// serializeattachmentIntermediateType will accept a attachmentIntermediateType to create a map 6194func serializeAttachmentIntermediateType(t *attachmentIntermediateType) (i interface{}, err error) { 6195 i, err = t.Serialize() 6196 return 6197 6198} 6199 6200// serializeSliceattachmentIntermediateType will accept a slice of attachmentIntermediateType to create a slice result 6201func serializeSliceAttachmentIntermediateType(s []*attachmentIntermediateType) (out []interface{}, err error) { 6202 for _, t := range s { 6203 v, err := t.Serialize() 6204 if err != nil { 6205 return nil, err 6206 } 6207 out = append(out, v) 6208 } 6209 return 6210 6211} 6212 6213// deserializecontextIntermediateType will accept a map to create a contextIntermediateType 6214func deserializeContextIntermediateType(in interface{}) (t *contextIntermediateType, err error) { 6215 tmp := &contextIntermediateType{} 6216 err = tmp.Deserialize(in) 6217 return tmp, err 6218 6219} 6220 6221// deserializeSlice contextIntermediateType will accept a slice to create a slice of contextIntermediateType 6222func deserializeSliceContextIntermediateType(in []interface{}) (t []*contextIntermediateType, err error) { 6223 for _, i := range in { 6224 tmp := &contextIntermediateType{} 6225 err = tmp.Deserialize(i) 6226 if err != nil { 6227 return 6228 } 6229 t = append(t, tmp) 6230 } 6231 return 6232 6233} 6234 6235// serializecontextIntermediateType will accept a contextIntermediateType to create a map 6236func serializeContextIntermediateType(t *contextIntermediateType) (i interface{}, err error) { 6237 i, err = t.Serialize() 6238 return 6239 6240} 6241 6242// serializeSlicecontextIntermediateType will accept a slice of contextIntermediateType to create a slice result 6243func serializeSliceContextIntermediateType(s []*contextIntermediateType) (out []interface{}, err error) { 6244 for _, t := range s { 6245 v, err := t.Serialize() 6246 if err != nil { 6247 return nil, err 6248 } 6249 out = append(out, v) 6250 } 6251 return 6252 6253} 6254 6255// deserializerepliesIntermediateType will accept a map to create a repliesIntermediateType 6256func deserializeRepliesIntermediateType(in interface{}) (t *repliesIntermediateType, err error) { 6257 tmp := &repliesIntermediateType{} 6258 err = tmp.Deserialize(in) 6259 return tmp, err 6260 6261} 6262 6263// deserializeSlice repliesIntermediateType will accept a slice to create a slice of repliesIntermediateType 6264func deserializeSliceRepliesIntermediateType(in []interface{}) (t []*repliesIntermediateType, err error) { 6265 for _, i := range in { 6266 tmp := &repliesIntermediateType{} 6267 err = tmp.Deserialize(i) 6268 if err != nil { 6269 return 6270 } 6271 t = append(t, tmp) 6272 } 6273 return 6274 6275} 6276 6277// serializerepliesIntermediateType will accept a repliesIntermediateType to create a map 6278func serializeRepliesIntermediateType(t *repliesIntermediateType) (i interface{}, err error) { 6279 i, err = t.Serialize() 6280 return 6281 6282} 6283 6284// serializeSlicerepliesIntermediateType will accept a slice of repliesIntermediateType to create a slice result 6285func serializeSliceRepliesIntermediateType(s []*repliesIntermediateType) (out []interface{}, err error) { 6286 for _, t := range s { 6287 v, err := t.Serialize() 6288 if err != nil { 6289 return nil, err 6290 } 6291 out = append(out, v) 6292 } 6293 return 6294 6295} 6296 6297// deserializeoutboxIntermediateType will accept a map to create a outboxIntermediateType 6298func deserializeOutboxIntermediateType(in interface{}) (t *outboxIntermediateType, err error) { 6299 tmp := &outboxIntermediateType{} 6300 err = tmp.Deserialize(in) 6301 return tmp, err 6302 6303} 6304 6305// deserializeSlice outboxIntermediateType will accept a slice to create a slice of outboxIntermediateType 6306func deserializeSliceOutboxIntermediateType(in []interface{}) (t []*outboxIntermediateType, err error) { 6307 for _, i := range in { 6308 tmp := &outboxIntermediateType{} 6309 err = tmp.Deserialize(i) 6310 if err != nil { 6311 return 6312 } 6313 t = append(t, tmp) 6314 } 6315 return 6316 6317} 6318 6319// serializeoutboxIntermediateType will accept a outboxIntermediateType to create a map 6320func serializeOutboxIntermediateType(t *outboxIntermediateType) (i interface{}, err error) { 6321 i, err = t.Serialize() 6322 return 6323 6324} 6325 6326// serializeSliceoutboxIntermediateType will accept a slice of outboxIntermediateType to create a slice result 6327func serializeSliceOutboxIntermediateType(s []*outboxIntermediateType) (out []interface{}, err error) { 6328 for _, t := range s { 6329 v, err := t.Serialize() 6330 if err != nil { 6331 return nil, err 6332 } 6333 out = append(out, v) 6334 } 6335 return 6336 6337} 6338 6339// deserializefirstIntermediateType will accept a map to create a firstIntermediateType 6340func deserializeFirstIntermediateType(in interface{}) (t *firstIntermediateType, err error) { 6341 tmp := &firstIntermediateType{} 6342 err = tmp.Deserialize(in) 6343 return tmp, err 6344 6345} 6346 6347// deserializeSlice firstIntermediateType will accept a slice to create a slice of firstIntermediateType 6348func deserializeSliceFirstIntermediateType(in []interface{}) (t []*firstIntermediateType, err error) { 6349 for _, i := range in { 6350 tmp := &firstIntermediateType{} 6351 err = tmp.Deserialize(i) 6352 if err != nil { 6353 return 6354 } 6355 t = append(t, tmp) 6356 } 6357 return 6358 6359} 6360 6361// serializefirstIntermediateType will accept a firstIntermediateType to create a map 6362func serializeFirstIntermediateType(t *firstIntermediateType) (i interface{}, err error) { 6363 i, err = t.Serialize() 6364 return 6365 6366} 6367 6368// serializeSlicefirstIntermediateType will accept a slice of firstIntermediateType to create a slice result 6369func serializeSliceFirstIntermediateType(s []*firstIntermediateType) (out []interface{}, err error) { 6370 for _, t := range s { 6371 v, err := t.Serialize() 6372 if err != nil { 6373 return nil, err 6374 } 6375 out = append(out, v) 6376 } 6377 return 6378 6379} 6380 6381// deserializerelationshipIntermediateType will accept a map to create a relationshipIntermediateType 6382func deserializeRelationshipIntermediateType(in interface{}) (t *relationshipIntermediateType, err error) { 6383 tmp := &relationshipIntermediateType{} 6384 err = tmp.Deserialize(in) 6385 return tmp, err 6386 6387} 6388 6389// deserializeSlice relationshipIntermediateType will accept a slice to create a slice of relationshipIntermediateType 6390func deserializeSliceRelationshipIntermediateType(in []interface{}) (t []*relationshipIntermediateType, err error) { 6391 for _, i := range in { 6392 tmp := &relationshipIntermediateType{} 6393 err = tmp.Deserialize(i) 6394 if err != nil { 6395 return 6396 } 6397 t = append(t, tmp) 6398 } 6399 return 6400 6401} 6402 6403// serializerelationshipIntermediateType will accept a relationshipIntermediateType to create a map 6404func serializeRelationshipIntermediateType(t *relationshipIntermediateType) (i interface{}, err error) { 6405 i, err = t.Serialize() 6406 return 6407 6408} 6409 6410// serializeSlicerelationshipIntermediateType will accept a slice of relationshipIntermediateType to create a slice result 6411func serializeSliceRelationshipIntermediateType(s []*relationshipIntermediateType) (out []interface{}, err error) { 6412 for _, t := range s { 6413 v, err := t.Serialize() 6414 if err != nil { 6415 return nil, err 6416 } 6417 out = append(out, v) 6418 } 6419 return 6420 6421} 6422 6423// deserializeradiusIntermediateType will accept a map to create a radiusIntermediateType 6424func deserializeRadiusIntermediateType(in interface{}) (t *radiusIntermediateType, err error) { 6425 tmp := &radiusIntermediateType{} 6426 err = tmp.Deserialize(in) 6427 return tmp, err 6428 6429} 6430 6431// deserializeSlice radiusIntermediateType will accept a slice to create a slice of radiusIntermediateType 6432func deserializeSliceRadiusIntermediateType(in []interface{}) (t []*radiusIntermediateType, err error) { 6433 for _, i := range in { 6434 tmp := &radiusIntermediateType{} 6435 err = tmp.Deserialize(i) 6436 if err != nil { 6437 return 6438 } 6439 t = append(t, tmp) 6440 } 6441 return 6442 6443} 6444 6445// serializeradiusIntermediateType will accept a radiusIntermediateType to create a map 6446func serializeRadiusIntermediateType(t *radiusIntermediateType) (i interface{}, err error) { 6447 i, err = t.Serialize() 6448 return 6449 6450} 6451 6452// serializeSliceradiusIntermediateType will accept a slice of radiusIntermediateType to create a slice result 6453func serializeSliceRadiusIntermediateType(s []*radiusIntermediateType) (out []interface{}, err error) { 6454 for _, t := range s { 6455 v, err := t.Serialize() 6456 if err != nil { 6457 return nil, err 6458 } 6459 out = append(out, v) 6460 } 6461 return 6462 6463} 6464 6465// deserializefollowingIntermediateType will accept a map to create a followingIntermediateType 6466func deserializeFollowingIntermediateType(in interface{}) (t *followingIntermediateType, err error) { 6467 tmp := &followingIntermediateType{} 6468 err = tmp.Deserialize(in) 6469 return tmp, err 6470 6471} 6472 6473// deserializeSlice followingIntermediateType will accept a slice to create a slice of followingIntermediateType 6474func deserializeSliceFollowingIntermediateType(in []interface{}) (t []*followingIntermediateType, err error) { 6475 for _, i := range in { 6476 tmp := &followingIntermediateType{} 6477 err = tmp.Deserialize(i) 6478 if err != nil { 6479 return 6480 } 6481 t = append(t, tmp) 6482 } 6483 return 6484 6485} 6486 6487// serializefollowingIntermediateType will accept a followingIntermediateType to create a map 6488func serializeFollowingIntermediateType(t *followingIntermediateType) (i interface{}, err error) { 6489 i, err = t.Serialize() 6490 return 6491 6492} 6493 6494// serializeSlicefollowingIntermediateType will accept a slice of followingIntermediateType to create a slice result 6495func serializeSliceFollowingIntermediateType(s []*followingIntermediateType) (out []interface{}, err error) { 6496 for _, t := range s { 6497 v, err := t.Serialize() 6498 if err != nil { 6499 return nil, err 6500 } 6501 out = append(out, v) 6502 } 6503 return 6504 6505} 6506 6507// deserializetotalItemsIntermediateType will accept a map to create a totalItemsIntermediateType 6508func deserializeTotalItemsIntermediateType(in interface{}) (t *totalItemsIntermediateType, err error) { 6509 tmp := &totalItemsIntermediateType{} 6510 err = tmp.Deserialize(in) 6511 return tmp, err 6512 6513} 6514 6515// deserializeSlice totalItemsIntermediateType will accept a slice to create a slice of totalItemsIntermediateType 6516func deserializeSliceTotalItemsIntermediateType(in []interface{}) (t []*totalItemsIntermediateType, err error) { 6517 for _, i := range in { 6518 tmp := &totalItemsIntermediateType{} 6519 err = tmp.Deserialize(i) 6520 if err != nil { 6521 return 6522 } 6523 t = append(t, tmp) 6524 } 6525 return 6526 6527} 6528 6529// serializetotalItemsIntermediateType will accept a totalItemsIntermediateType to create a map 6530func serializeTotalItemsIntermediateType(t *totalItemsIntermediateType) (i interface{}, err error) { 6531 i, err = t.Serialize() 6532 return 6533 6534} 6535 6536// serializeSlicetotalItemsIntermediateType will accept a slice of totalItemsIntermediateType to create a slice result 6537func serializeSliceTotalItemsIntermediateType(s []*totalItemsIntermediateType) (out []interface{}, err error) { 6538 for _, t := range s { 6539 v, err := t.Serialize() 6540 if err != nil { 6541 return nil, err 6542 } 6543 out = append(out, v) 6544 } 6545 return 6546 6547} 6548 6549// deserializestartIndexIntermediateType will accept a map to create a startIndexIntermediateType 6550func deserializeStartIndexIntermediateType(in interface{}) (t *startIndexIntermediateType, err error) { 6551 tmp := &startIndexIntermediateType{} 6552 err = tmp.Deserialize(in) 6553 return tmp, err 6554 6555} 6556 6557// deserializeSlice startIndexIntermediateType will accept a slice to create a slice of startIndexIntermediateType 6558func deserializeSliceStartIndexIntermediateType(in []interface{}) (t []*startIndexIntermediateType, err error) { 6559 for _, i := range in { 6560 tmp := &startIndexIntermediateType{} 6561 err = tmp.Deserialize(i) 6562 if err != nil { 6563 return 6564 } 6565 t = append(t, tmp) 6566 } 6567 return 6568 6569} 6570 6571// serializestartIndexIntermediateType will accept a startIndexIntermediateType to create a map 6572func serializeStartIndexIntermediateType(t *startIndexIntermediateType) (i interface{}, err error) { 6573 i, err = t.Serialize() 6574 return 6575 6576} 6577 6578// serializeSlicestartIndexIntermediateType will accept a slice of startIndexIntermediateType to create a slice result 6579func serializeSliceStartIndexIntermediateType(s []*startIndexIntermediateType) (out []interface{}, err error) { 6580 for _, t := range s { 6581 v, err := t.Serialize() 6582 if err != nil { 6583 return nil, err 6584 } 6585 out = append(out, v) 6586 } 6587 return 6588 6589} 6590 6591// deserializeaccuracyIntermediateType will accept a map to create a accuracyIntermediateType 6592func deserializeAccuracyIntermediateType(in interface{}) (t *accuracyIntermediateType, err error) { 6593 tmp := &accuracyIntermediateType{} 6594 err = tmp.Deserialize(in) 6595 return tmp, err 6596 6597} 6598 6599// deserializeSlice accuracyIntermediateType will accept a slice to create a slice of accuracyIntermediateType 6600func deserializeSliceAccuracyIntermediateType(in []interface{}) (t []*accuracyIntermediateType, err error) { 6601 for _, i := range in { 6602 tmp := &accuracyIntermediateType{} 6603 err = tmp.Deserialize(i) 6604 if err != nil { 6605 return 6606 } 6607 t = append(t, tmp) 6608 } 6609 return 6610 6611} 6612 6613// serializeaccuracyIntermediateType will accept a accuracyIntermediateType to create a map 6614func serializeAccuracyIntermediateType(t *accuracyIntermediateType) (i interface{}, err error) { 6615 i, err = t.Serialize() 6616 return 6617 6618} 6619 6620// serializeSliceaccuracyIntermediateType will accept a slice of accuracyIntermediateType to create a slice result 6621func serializeSliceAccuracyIntermediateType(s []*accuracyIntermediateType) (out []interface{}, err error) { 6622 for _, t := range s { 6623 v, err := t.Serialize() 6624 if err != nil { 6625 return nil, err 6626 } 6627 out = append(out, v) 6628 } 6629 return 6630 6631} 6632 6633// deserializeprevIntermediateType will accept a map to create a prevIntermediateType 6634func deserializePrevIntermediateType(in interface{}) (t *prevIntermediateType, err error) { 6635 tmp := &prevIntermediateType{} 6636 err = tmp.Deserialize(in) 6637 return tmp, err 6638 6639} 6640 6641// deserializeSlice prevIntermediateType will accept a slice to create a slice of prevIntermediateType 6642func deserializeSlicePrevIntermediateType(in []interface{}) (t []*prevIntermediateType, err error) { 6643 for _, i := range in { 6644 tmp := &prevIntermediateType{} 6645 err = tmp.Deserialize(i) 6646 if err != nil { 6647 return 6648 } 6649 t = append(t, tmp) 6650 } 6651 return 6652 6653} 6654 6655// serializeprevIntermediateType will accept a prevIntermediateType to create a map 6656func serializePrevIntermediateType(t *prevIntermediateType) (i interface{}, err error) { 6657 i, err = t.Serialize() 6658 return 6659 6660} 6661 6662// serializeSliceprevIntermediateType will accept a slice of prevIntermediateType to create a slice result 6663func serializeSlicePrevIntermediateType(s []*prevIntermediateType) (out []interface{}, err error) { 6664 for _, t := range s { 6665 v, err := t.Serialize() 6666 if err != nil { 6667 return nil, err 6668 } 6669 out = append(out, v) 6670 } 6671 return 6672 6673} 6674 6675// deserializepublishedIntermediateType will accept a map to create a publishedIntermediateType 6676func deserializePublishedIntermediateType(in interface{}) (t *publishedIntermediateType, err error) { 6677 tmp := &publishedIntermediateType{} 6678 err = tmp.Deserialize(in) 6679 return tmp, err 6680 6681} 6682 6683// deserializeSlice publishedIntermediateType will accept a slice to create a slice of publishedIntermediateType 6684func deserializeSlicePublishedIntermediateType(in []interface{}) (t []*publishedIntermediateType, err error) { 6685 for _, i := range in { 6686 tmp := &publishedIntermediateType{} 6687 err = tmp.Deserialize(i) 6688 if err != nil { 6689 return 6690 } 6691 t = append(t, tmp) 6692 } 6693 return 6694 6695} 6696 6697// serializepublishedIntermediateType will accept a publishedIntermediateType to create a map 6698func serializePublishedIntermediateType(t *publishedIntermediateType) (i interface{}, err error) { 6699 i, err = t.Serialize() 6700 return 6701 6702} 6703 6704// serializeSlicepublishedIntermediateType will accept a slice of publishedIntermediateType to create a slice result 6705func serializeSlicePublishedIntermediateType(s []*publishedIntermediateType) (out []interface{}, err error) { 6706 for _, t := range s { 6707 v, err := t.Serialize() 6708 if err != nil { 6709 return nil, err 6710 } 6711 out = append(out, v) 6712 } 6713 return 6714 6715} 6716 6717// deserializeupdatedIntermediateType will accept a map to create a updatedIntermediateType 6718func deserializeUpdatedIntermediateType(in interface{}) (t *updatedIntermediateType, err error) { 6719 tmp := &updatedIntermediateType{} 6720 err = tmp.Deserialize(in) 6721 return tmp, err 6722 6723} 6724 6725// deserializeSlice updatedIntermediateType will accept a slice to create a slice of updatedIntermediateType 6726func deserializeSliceUpdatedIntermediateType(in []interface{}) (t []*updatedIntermediateType, err error) { 6727 for _, i := range in { 6728 tmp := &updatedIntermediateType{} 6729 err = tmp.Deserialize(i) 6730 if err != nil { 6731 return 6732 } 6733 t = append(t, tmp) 6734 } 6735 return 6736 6737} 6738 6739// serializeupdatedIntermediateType will accept a updatedIntermediateType to create a map 6740func serializeUpdatedIntermediateType(t *updatedIntermediateType) (i interface{}, err error) { 6741 i, err = t.Serialize() 6742 return 6743 6744} 6745 6746// serializeSliceupdatedIntermediateType will accept a slice of updatedIntermediateType to create a slice result 6747func serializeSliceUpdatedIntermediateType(s []*updatedIntermediateType) (out []interface{}, err error) { 6748 for _, t := range s { 6749 v, err := t.Serialize() 6750 if err != nil { 6751 return nil, err 6752 } 6753 out = append(out, v) 6754 } 6755 return 6756 6757} 6758 6759// deserializeactorIntermediateType will accept a map to create a actorIntermediateType 6760func deserializeActorIntermediateType(in interface{}) (t *actorIntermediateType, err error) { 6761 tmp := &actorIntermediateType{} 6762 err = tmp.Deserialize(in) 6763 return tmp, err 6764 6765} 6766 6767// deserializeSlice actorIntermediateType will accept a slice to create a slice of actorIntermediateType 6768func deserializeSliceActorIntermediateType(in []interface{}) (t []*actorIntermediateType, err error) { 6769 for _, i := range in { 6770 tmp := &actorIntermediateType{} 6771 err = tmp.Deserialize(i) 6772 if err != nil { 6773 return 6774 } 6775 t = append(t, tmp) 6776 } 6777 return 6778 6779} 6780 6781// serializeactorIntermediateType will accept a actorIntermediateType to create a map 6782func serializeActorIntermediateType(t *actorIntermediateType) (i interface{}, err error) { 6783 i, err = t.Serialize() 6784 return 6785 6786} 6787 6788// serializeSliceactorIntermediateType will accept a slice of actorIntermediateType to create a slice result 6789func serializeSliceActorIntermediateType(s []*actorIntermediateType) (out []interface{}, err error) { 6790 for _, t := range s { 6791 v, err := t.Serialize() 6792 if err != nil { 6793 return nil, err 6794 } 6795 out = append(out, v) 6796 } 6797 return 6798 6799} 6800 6801// deserializeobjectIntermediateType will accept a map to create a objectIntermediateType 6802func deserializeObjectIntermediateType(in interface{}) (t *objectIntermediateType, err error) { 6803 tmp := &objectIntermediateType{} 6804 err = tmp.Deserialize(in) 6805 return tmp, err 6806 6807} 6808 6809// deserializeSlice objectIntermediateType will accept a slice to create a slice of objectIntermediateType 6810func deserializeSliceObjectIntermediateType(in []interface{}) (t []*objectIntermediateType, err error) { 6811 for _, i := range in { 6812 tmp := &objectIntermediateType{} 6813 err = tmp.Deserialize(i) 6814 if err != nil { 6815 return 6816 } 6817 t = append(t, tmp) 6818 } 6819 return 6820 6821} 6822 6823// serializeobjectIntermediateType will accept a objectIntermediateType to create a map 6824func serializeObjectIntermediateType(t *objectIntermediateType) (i interface{}, err error) { 6825 i, err = t.Serialize() 6826 return 6827 6828} 6829 6830// serializeSliceobjectIntermediateType will accept a slice of objectIntermediateType to create a slice result 6831func serializeSliceObjectIntermediateType(s []*objectIntermediateType) (out []interface{}, err error) { 6832 for _, t := range s { 6833 v, err := t.Serialize() 6834 if err != nil { 6835 return nil, err 6836 } 6837 out = append(out, v) 6838 } 6839 return 6840 6841} 6842 6843// deserializecurrentIntermediateType will accept a map to create a currentIntermediateType 6844func deserializeCurrentIntermediateType(in interface{}) (t *currentIntermediateType, err error) { 6845 tmp := ¤tIntermediateType{} 6846 err = tmp.Deserialize(in) 6847 return tmp, err 6848 6849} 6850 6851// deserializeSlice currentIntermediateType will accept a slice to create a slice of currentIntermediateType 6852func deserializeSliceCurrentIntermediateType(in []interface{}) (t []*currentIntermediateType, err error) { 6853 for _, i := range in { 6854 tmp := ¤tIntermediateType{} 6855 err = tmp.Deserialize(i) 6856 if err != nil { 6857 return 6858 } 6859 t = append(t, tmp) 6860 } 6861 return 6862 6863} 6864 6865// serializecurrentIntermediateType will accept a currentIntermediateType to create a map 6866func serializeCurrentIntermediateType(t *currentIntermediateType) (i interface{}, err error) { 6867 i, err = t.Serialize() 6868 return 6869 6870} 6871 6872// serializeSlicecurrentIntermediateType will accept a slice of currentIntermediateType to create a slice result 6873func serializeSliceCurrentIntermediateType(s []*currentIntermediateType) (out []interface{}, err error) { 6874 for _, t := range s { 6875 v, err := t.Serialize() 6876 if err != nil { 6877 return nil, err 6878 } 6879 out = append(out, v) 6880 } 6881 return 6882 6883} 6884 6885// deserializeformerTypeIntermediateType will accept a map to create a formerTypeIntermediateType 6886func deserializeFormerTypeIntermediateType(in interface{}) (t *formerTypeIntermediateType, err error) { 6887 tmp := &formerTypeIntermediateType{} 6888 err = tmp.Deserialize(in) 6889 return tmp, err 6890 6891} 6892 6893// deserializeSlice formerTypeIntermediateType will accept a slice to create a slice of formerTypeIntermediateType 6894func deserializeSliceFormerTypeIntermediateType(in []interface{}) (t []*formerTypeIntermediateType, err error) { 6895 for _, i := range in { 6896 tmp := &formerTypeIntermediateType{} 6897 err = tmp.Deserialize(i) 6898 if err != nil { 6899 return 6900 } 6901 t = append(t, tmp) 6902 } 6903 return 6904 6905} 6906 6907// serializeformerTypeIntermediateType will accept a formerTypeIntermediateType to create a map 6908func serializeFormerTypeIntermediateType(t *formerTypeIntermediateType) (i interface{}, err error) { 6909 i, err = t.Serialize() 6910 return 6911 6912} 6913 6914// serializeSliceformerTypeIntermediateType will accept a slice of formerTypeIntermediateType to create a slice result 6915func serializeSliceFormerTypeIntermediateType(s []*formerTypeIntermediateType) (out []interface{}, err error) { 6916 for _, t := range s { 6917 v, err := t.Serialize() 6918 if err != nil { 6919 return nil, err 6920 } 6921 out = append(out, v) 6922 } 6923 return 6924 6925} 6926 6927// deserializeiconIntermediateType will accept a map to create a iconIntermediateType 6928func deserializeIconIntermediateType(in interface{}) (t *iconIntermediateType, err error) { 6929 tmp := &iconIntermediateType{} 6930 err = tmp.Deserialize(in) 6931 return tmp, err 6932 6933} 6934 6935// deserializeSlice iconIntermediateType will accept a slice to create a slice of iconIntermediateType 6936func deserializeSliceIconIntermediateType(in []interface{}) (t []*iconIntermediateType, err error) { 6937 for _, i := range in { 6938 tmp := &iconIntermediateType{} 6939 err = tmp.Deserialize(i) 6940 if err != nil { 6941 return 6942 } 6943 t = append(t, tmp) 6944 } 6945 return 6946 6947} 6948 6949// serializeiconIntermediateType will accept a iconIntermediateType to create a map 6950func serializeIconIntermediateType(t *iconIntermediateType) (i interface{}, err error) { 6951 i, err = t.Serialize() 6952 return 6953 6954} 6955 6956// serializeSliceiconIntermediateType will accept a slice of iconIntermediateType to create a slice result 6957func serializeSliceIconIntermediateType(s []*iconIntermediateType) (out []interface{}, err error) { 6958 for _, t := range s { 6959 v, err := t.Serialize() 6960 if err != nil { 6961 return nil, err 6962 } 6963 out = append(out, v) 6964 } 6965 return 6966 6967} 6968 6969// deserializerelIntermediateType will accept a map to create a relIntermediateType 6970func deserializeRelIntermediateType(in interface{}) (t *relIntermediateType, err error) { 6971 tmp := &relIntermediateType{} 6972 err = tmp.Deserialize(in) 6973 return tmp, err 6974 6975} 6976 6977// deserializeSlice relIntermediateType will accept a slice to create a slice of relIntermediateType 6978func deserializeSliceRelIntermediateType(in []interface{}) (t []*relIntermediateType, err error) { 6979 for _, i := range in { 6980 tmp := &relIntermediateType{} 6981 err = tmp.Deserialize(i) 6982 if err != nil { 6983 return 6984 } 6985 t = append(t, tmp) 6986 } 6987 return 6988 6989} 6990 6991// serializerelIntermediateType will accept a relIntermediateType to create a map 6992func serializeRelIntermediateType(t *relIntermediateType) (i interface{}, err error) { 6993 i, err = t.Serialize() 6994 return 6995 6996} 6997 6998// serializeSlicerelIntermediateType will accept a slice of relIntermediateType to create a slice result 6999func serializeSliceRelIntermediateType(s []*relIntermediateType) (out []interface{}, err error) { 7000 for _, t := range s { 7001 v, err := t.Serialize() 7002 if err != nil { 7003 return nil, err 7004 } 7005 out = append(out, v) 7006 } 7007 return 7008 7009} 7010 7011// deserializeoriginIntermediateType will accept a map to create a originIntermediateType 7012func deserializeOriginIntermediateType(in interface{}) (t *originIntermediateType, err error) { 7013 tmp := &originIntermediateType{} 7014 err = tmp.Deserialize(in) 7015 return tmp, err 7016 7017} 7018 7019// deserializeSlice originIntermediateType will accept a slice to create a slice of originIntermediateType 7020func deserializeSliceOriginIntermediateType(in []interface{}) (t []*originIntermediateType, err error) { 7021 for _, i := range in { 7022 tmp := &originIntermediateType{} 7023 err = tmp.Deserialize(i) 7024 if err != nil { 7025 return 7026 } 7027 t = append(t, tmp) 7028 } 7029 return 7030 7031} 7032 7033// serializeoriginIntermediateType will accept a originIntermediateType to create a map 7034func serializeOriginIntermediateType(t *originIntermediateType) (i interface{}, err error) { 7035 i, err = t.Serialize() 7036 return 7037 7038} 7039 7040// serializeSliceoriginIntermediateType will accept a slice of originIntermediateType to create a slice result 7041func serializeSliceOriginIntermediateType(s []*originIntermediateType) (out []interface{}, err error) { 7042 for _, t := range s { 7043 v, err := t.Serialize() 7044 if err != nil { 7045 return nil, err 7046 } 7047 out = append(out, v) 7048 } 7049 return 7050 7051} 7052 7053// deserializeorderedItemsIntermediateType will accept a map to create a orderedItemsIntermediateType 7054func deserializeOrderedItemsIntermediateType(in interface{}) (t *orderedItemsIntermediateType, err error) { 7055 tmp := &orderedItemsIntermediateType{} 7056 err = tmp.Deserialize(in) 7057 return tmp, err 7058 7059} 7060 7061// deserializeSlice orderedItemsIntermediateType will accept a slice to create a slice of orderedItemsIntermediateType 7062func deserializeSliceOrderedItemsIntermediateType(in []interface{}) (t []*orderedItemsIntermediateType, err error) { 7063 for _, i := range in { 7064 tmp := &orderedItemsIntermediateType{} 7065 err = tmp.Deserialize(i) 7066 if err != nil { 7067 return 7068 } 7069 t = append(t, tmp) 7070 } 7071 return 7072 7073} 7074 7075// serializeorderedItemsIntermediateType will accept a orderedItemsIntermediateType to create a map 7076func serializeOrderedItemsIntermediateType(t *orderedItemsIntermediateType) (i interface{}, err error) { 7077 i, err = t.Serialize() 7078 return 7079 7080} 7081 7082// serializeSliceorderedItemsIntermediateType will accept a slice of orderedItemsIntermediateType to create a slice result 7083func serializeSliceOrderedItemsIntermediateType(s []*orderedItemsIntermediateType) (out []interface{}, err error) { 7084 for _, t := range s { 7085 v, err := t.Serialize() 7086 if err != nil { 7087 return nil, err 7088 } 7089 out = append(out, v) 7090 } 7091 return 7092 7093} 7094 7095// deserializenextIntermediateType will accept a map to create a nextIntermediateType 7096func deserializeNextIntermediateType(in interface{}) (t *nextIntermediateType, err error) { 7097 tmp := &nextIntermediateType{} 7098 err = tmp.Deserialize(in) 7099 return tmp, err 7100 7101} 7102 7103// deserializeSlice nextIntermediateType will accept a slice to create a slice of nextIntermediateType 7104func deserializeSliceNextIntermediateType(in []interface{}) (t []*nextIntermediateType, err error) { 7105 for _, i := range in { 7106 tmp := &nextIntermediateType{} 7107 err = tmp.Deserialize(i) 7108 if err != nil { 7109 return 7110 } 7111 t = append(t, tmp) 7112 } 7113 return 7114 7115} 7116 7117// serializenextIntermediateType will accept a nextIntermediateType to create a map 7118func serializeNextIntermediateType(t *nextIntermediateType) (i interface{}, err error) { 7119 i, err = t.Serialize() 7120 return 7121 7122} 7123 7124// serializeSlicenextIntermediateType will accept a slice of nextIntermediateType to create a slice result 7125func serializeSliceNextIntermediateType(s []*nextIntermediateType) (out []interface{}, err error) { 7126 for _, t := range s { 7127 v, err := t.Serialize() 7128 if err != nil { 7129 return nil, err 7130 } 7131 out = append(out, v) 7132 } 7133 return 7134 7135} 7136 7137// deserializeinReplyToIntermediateType will accept a map to create a inReplyToIntermediateType 7138func deserializeInReplyToIntermediateType(in interface{}) (t *inReplyToIntermediateType, err error) { 7139 tmp := &inReplyToIntermediateType{} 7140 err = tmp.Deserialize(in) 7141 return tmp, err 7142 7143} 7144 7145// deserializeSlice inReplyToIntermediateType will accept a slice to create a slice of inReplyToIntermediateType 7146func deserializeSliceInReplyToIntermediateType(in []interface{}) (t []*inReplyToIntermediateType, err error) { 7147 for _, i := range in { 7148 tmp := &inReplyToIntermediateType{} 7149 err = tmp.Deserialize(i) 7150 if err != nil { 7151 return 7152 } 7153 t = append(t, tmp) 7154 } 7155 return 7156 7157} 7158 7159// serializeinReplyToIntermediateType will accept a inReplyToIntermediateType to create a map 7160func serializeInReplyToIntermediateType(t *inReplyToIntermediateType) (i interface{}, err error) { 7161 i, err = t.Serialize() 7162 return 7163 7164} 7165 7166// serializeSliceinReplyToIntermediateType will accept a slice of inReplyToIntermediateType to create a slice result 7167func serializeSliceInReplyToIntermediateType(s []*inReplyToIntermediateType) (out []interface{}, err error) { 7168 for _, t := range s { 7169 v, err := t.Serialize() 7170 if err != nil { 7171 return nil, err 7172 } 7173 out = append(out, v) 7174 } 7175 return 7176 7177} 7178 7179// deserializebtoIntermediateType will accept a map to create a btoIntermediateType 7180func deserializeBtoIntermediateType(in interface{}) (t *btoIntermediateType, err error) { 7181 tmp := &btoIntermediateType{} 7182 err = tmp.Deserialize(in) 7183 return tmp, err 7184 7185} 7186 7187// deserializeSlice btoIntermediateType will accept a slice to create a slice of btoIntermediateType 7188func deserializeSliceBtoIntermediateType(in []interface{}) (t []*btoIntermediateType, err error) { 7189 for _, i := range in { 7190 tmp := &btoIntermediateType{} 7191 err = tmp.Deserialize(i) 7192 if err != nil { 7193 return 7194 } 7195 t = append(t, tmp) 7196 } 7197 return 7198 7199} 7200 7201// serializebtoIntermediateType will accept a btoIntermediateType to create a map 7202func serializeBtoIntermediateType(t *btoIntermediateType) (i interface{}, err error) { 7203 i, err = t.Serialize() 7204 return 7205 7206} 7207 7208// serializeSlicebtoIntermediateType will accept a slice of btoIntermediateType to create a slice result 7209func serializeSliceBtoIntermediateType(s []*btoIntermediateType) (out []interface{}, err error) { 7210 for _, t := range s { 7211 v, err := t.Serialize() 7212 if err != nil { 7213 return nil, err 7214 } 7215 out = append(out, v) 7216 } 7217 return 7218 7219} 7220 7221// deserializemediaTypeIntermediateType will accept a map to create a mediaTypeIntermediateType 7222func deserializeMediaTypeIntermediateType(in interface{}) (t *mediaTypeIntermediateType, err error) { 7223 tmp := &mediaTypeIntermediateType{} 7224 err = tmp.Deserialize(in) 7225 return tmp, err 7226 7227} 7228 7229// deserializeSlice mediaTypeIntermediateType will accept a slice to create a slice of mediaTypeIntermediateType 7230func deserializeSliceMediaTypeIntermediateType(in []interface{}) (t []*mediaTypeIntermediateType, err error) { 7231 for _, i := range in { 7232 tmp := &mediaTypeIntermediateType{} 7233 err = tmp.Deserialize(i) 7234 if err != nil { 7235 return 7236 } 7237 t = append(t, tmp) 7238 } 7239 return 7240 7241} 7242 7243// serializemediaTypeIntermediateType will accept a mediaTypeIntermediateType to create a map 7244func serializeMediaTypeIntermediateType(t *mediaTypeIntermediateType) (i interface{}, err error) { 7245 i, err = t.Serialize() 7246 return 7247 7248} 7249 7250// serializeSlicemediaTypeIntermediateType will accept a slice of mediaTypeIntermediateType to create a slice result 7251func serializeSliceMediaTypeIntermediateType(s []*mediaTypeIntermediateType) (out []interface{}, err error) { 7252 for _, t := range s { 7253 v, err := t.Serialize() 7254 if err != nil { 7255 return nil, err 7256 } 7257 out = append(out, v) 7258 } 7259 return 7260 7261} 7262 7263// deserializeendTimeIntermediateType will accept a map to create a endTimeIntermediateType 7264func deserializeEndTimeIntermediateType(in interface{}) (t *endTimeIntermediateType, err error) { 7265 tmp := &endTimeIntermediateType{} 7266 err = tmp.Deserialize(in) 7267 return tmp, err 7268 7269} 7270 7271// deserializeSlice endTimeIntermediateType will accept a slice to create a slice of endTimeIntermediateType 7272func deserializeSliceEndTimeIntermediateType(in []interface{}) (t []*endTimeIntermediateType, err error) { 7273 for _, i := range in { 7274 tmp := &endTimeIntermediateType{} 7275 err = tmp.Deserialize(i) 7276 if err != nil { 7277 return 7278 } 7279 t = append(t, tmp) 7280 } 7281 return 7282 7283} 7284 7285// serializeendTimeIntermediateType will accept a endTimeIntermediateType to create a map 7286func serializeEndTimeIntermediateType(t *endTimeIntermediateType) (i interface{}, err error) { 7287 i, err = t.Serialize() 7288 return 7289 7290} 7291 7292// serializeSliceendTimeIntermediateType will accept a slice of endTimeIntermediateType to create a slice result 7293func serializeSliceEndTimeIntermediateType(s []*endTimeIntermediateType) (out []interface{}, err error) { 7294 for _, t := range s { 7295 v, err := t.Serialize() 7296 if err != nil { 7297 return nil, err 7298 } 7299 out = append(out, v) 7300 } 7301 return 7302 7303} 7304 7305// deserializeurlIntermediateType will accept a map to create a urlIntermediateType 7306func deserializeUrlIntermediateType(in interface{}) (t *urlIntermediateType, err error) { 7307 tmp := &urlIntermediateType{} 7308 err = tmp.Deserialize(in) 7309 return tmp, err 7310 7311} 7312 7313// deserializeSlice urlIntermediateType will accept a slice to create a slice of urlIntermediateType 7314func deserializeSliceUrlIntermediateType(in []interface{}) (t []*urlIntermediateType, err error) { 7315 for _, i := range in { 7316 tmp := &urlIntermediateType{} 7317 err = tmp.Deserialize(i) 7318 if err != nil { 7319 return 7320 } 7321 t = append(t, tmp) 7322 } 7323 return 7324 7325} 7326 7327// serializeurlIntermediateType will accept a urlIntermediateType to create a map 7328func serializeUrlIntermediateType(t *urlIntermediateType) (i interface{}, err error) { 7329 i, err = t.Serialize() 7330 return 7331 7332} 7333 7334// serializeSliceurlIntermediateType will accept a slice of urlIntermediateType to create a slice result 7335func serializeSliceUrlIntermediateType(s []*urlIntermediateType) (out []interface{}, err error) { 7336 for _, t := range s { 7337 v, err := t.Serialize() 7338 if err != nil { 7339 return nil, err 7340 } 7341 out = append(out, v) 7342 } 7343 return 7344 7345} 7346 7347// deserializewidthIntermediateType will accept a map to create a widthIntermediateType 7348func deserializeWidthIntermediateType(in interface{}) (t *widthIntermediateType, err error) { 7349 tmp := &widthIntermediateType{} 7350 err = tmp.Deserialize(in) 7351 return tmp, err 7352 7353} 7354 7355// deserializeSlice widthIntermediateType will accept a slice to create a slice of widthIntermediateType 7356func deserializeSliceWidthIntermediateType(in []interface{}) (t []*widthIntermediateType, err error) { 7357 for _, i := range in { 7358 tmp := &widthIntermediateType{} 7359 err = tmp.Deserialize(i) 7360 if err != nil { 7361 return 7362 } 7363 t = append(t, tmp) 7364 } 7365 return 7366 7367} 7368 7369// serializewidthIntermediateType will accept a widthIntermediateType to create a map 7370func serializeWidthIntermediateType(t *widthIntermediateType) (i interface{}, err error) { 7371 i, err = t.Serialize() 7372 return 7373 7374} 7375 7376// serializeSlicewidthIntermediateType will accept a slice of widthIntermediateType to create a slice result 7377func serializeSliceWidthIntermediateType(s []*widthIntermediateType) (out []interface{}, err error) { 7378 for _, t := range s { 7379 v, err := t.Serialize() 7380 if err != nil { 7381 return nil, err 7382 } 7383 out = append(out, v) 7384 } 7385 return 7386 7387} 7388 7389// deserializepartOfIntermediateType will accept a map to create a partOfIntermediateType 7390func deserializePartOfIntermediateType(in interface{}) (t *partOfIntermediateType, err error) { 7391 tmp := &partOfIntermediateType{} 7392 err = tmp.Deserialize(in) 7393 return tmp, err 7394 7395} 7396 7397// deserializeSlice partOfIntermediateType will accept a slice to create a slice of partOfIntermediateType 7398func deserializeSlicePartOfIntermediateType(in []interface{}) (t []*partOfIntermediateType, err error) { 7399 for _, i := range in { 7400 tmp := &partOfIntermediateType{} 7401 err = tmp.Deserialize(i) 7402 if err != nil { 7403 return 7404 } 7405 t = append(t, tmp) 7406 } 7407 return 7408 7409} 7410 7411// serializepartOfIntermediateType will accept a partOfIntermediateType to create a map 7412func serializePartOfIntermediateType(t *partOfIntermediateType) (i interface{}, err error) { 7413 i, err = t.Serialize() 7414 return 7415 7416} 7417 7418// serializeSlicepartOfIntermediateType will accept a slice of partOfIntermediateType to create a slice result 7419func serializeSlicePartOfIntermediateType(s []*partOfIntermediateType) (out []interface{}, err error) { 7420 for _, t := range s { 7421 v, err := t.Serialize() 7422 if err != nil { 7423 return nil, err 7424 } 7425 out = append(out, v) 7426 } 7427 return 7428 7429} 7430 7431// deserializeimageIntermediateType will accept a map to create a imageIntermediateType 7432func deserializeImageIntermediateType(in interface{}) (t *imageIntermediateType, err error) { 7433 tmp := &imageIntermediateType{} 7434 err = tmp.Deserialize(in) 7435 return tmp, err 7436 7437} 7438 7439// deserializeSlice imageIntermediateType will accept a slice to create a slice of imageIntermediateType 7440func deserializeSliceImageIntermediateType(in []interface{}) (t []*imageIntermediateType, err error) { 7441 for _, i := range in { 7442 tmp := &imageIntermediateType{} 7443 err = tmp.Deserialize(i) 7444 if err != nil { 7445 return 7446 } 7447 t = append(t, tmp) 7448 } 7449 return 7450 7451} 7452 7453// serializeimageIntermediateType will accept a imageIntermediateType to create a map 7454func serializeImageIntermediateType(t *imageIntermediateType) (i interface{}, err error) { 7455 i, err = t.Serialize() 7456 return 7457 7458} 7459 7460// serializeSliceimageIntermediateType will accept a slice of imageIntermediateType to create a slice result 7461func serializeSliceImageIntermediateType(s []*imageIntermediateType) (out []interface{}, err error) { 7462 for _, t := range s { 7463 v, err := t.Serialize() 7464 if err != nil { 7465 return nil, err 7466 } 7467 out = append(out, v) 7468 } 7469 return 7470 7471} 7472 7473// deserializeccIntermediateType will accept a map to create a ccIntermediateType 7474func deserializeCcIntermediateType(in interface{}) (t *ccIntermediateType, err error) { 7475 tmp := &ccIntermediateType{} 7476 err = tmp.Deserialize(in) 7477 return tmp, err 7478 7479} 7480 7481// deserializeSlice ccIntermediateType will accept a slice to create a slice of ccIntermediateType 7482func deserializeSliceCcIntermediateType(in []interface{}) (t []*ccIntermediateType, err error) { 7483 for _, i := range in { 7484 tmp := &ccIntermediateType{} 7485 err = tmp.Deserialize(i) 7486 if err != nil { 7487 return 7488 } 7489 t = append(t, tmp) 7490 } 7491 return 7492 7493} 7494 7495// serializeccIntermediateType will accept a ccIntermediateType to create a map 7496func serializeCcIntermediateType(t *ccIntermediateType) (i interface{}, err error) { 7497 i, err = t.Serialize() 7498 return 7499 7500} 7501 7502// serializeSliceccIntermediateType will accept a slice of ccIntermediateType to create a slice result 7503func serializeSliceCcIntermediateType(s []*ccIntermediateType) (out []interface{}, err error) { 7504 for _, t := range s { 7505 v, err := t.Serialize() 7506 if err != nil { 7507 return nil, err 7508 } 7509 out = append(out, v) 7510 } 7511 return 7512 7513} 7514 7515// deserializeinstrumentIntermediateType will accept a map to create a instrumentIntermediateType 7516func deserializeInstrumentIntermediateType(in interface{}) (t *instrumentIntermediateType, err error) { 7517 tmp := &instrumentIntermediateType{} 7518 err = tmp.Deserialize(in) 7519 return tmp, err 7520 7521} 7522 7523// deserializeSlice instrumentIntermediateType will accept a slice to create a slice of instrumentIntermediateType 7524func deserializeSliceInstrumentIntermediateType(in []interface{}) (t []*instrumentIntermediateType, err error) { 7525 for _, i := range in { 7526 tmp := &instrumentIntermediateType{} 7527 err = tmp.Deserialize(i) 7528 if err != nil { 7529 return 7530 } 7531 t = append(t, tmp) 7532 } 7533 return 7534 7535} 7536 7537// serializeinstrumentIntermediateType will accept a instrumentIntermediateType to create a map 7538func serializeInstrumentIntermediateType(t *instrumentIntermediateType) (i interface{}, err error) { 7539 i, err = t.Serialize() 7540 return 7541 7542} 7543 7544// serializeSliceinstrumentIntermediateType will accept a slice of instrumentIntermediateType to create a slice result 7545func serializeSliceInstrumentIntermediateType(s []*instrumentIntermediateType) (out []interface{}, err error) { 7546 for _, t := range s { 7547 v, err := t.Serialize() 7548 if err != nil { 7549 return nil, err 7550 } 7551 out = append(out, v) 7552 } 7553 return 7554 7555} 7556 7557// deserializelastIntermediateType will accept a map to create a lastIntermediateType 7558func deserializeLastIntermediateType(in interface{}) (t *lastIntermediateType, err error) { 7559 tmp := &lastIntermediateType{} 7560 err = tmp.Deserialize(in) 7561 return tmp, err 7562 7563} 7564 7565// deserializeSlice lastIntermediateType will accept a slice to create a slice of lastIntermediateType 7566func deserializeSliceLastIntermediateType(in []interface{}) (t []*lastIntermediateType, err error) { 7567 for _, i := range in { 7568 tmp := &lastIntermediateType{} 7569 err = tmp.Deserialize(i) 7570 if err != nil { 7571 return 7572 } 7573 t = append(t, tmp) 7574 } 7575 return 7576 7577} 7578 7579// serializelastIntermediateType will accept a lastIntermediateType to create a map 7580func serializeLastIntermediateType(t *lastIntermediateType) (i interface{}, err error) { 7581 i, err = t.Serialize() 7582 return 7583 7584} 7585 7586// serializeSlicelastIntermediateType will accept a slice of lastIntermediateType to create a slice result 7587func serializeSliceLastIntermediateType(s []*lastIntermediateType) (out []interface{}, err error) { 7588 for _, t := range s { 7589 v, err := t.Serialize() 7590 if err != nil { 7591 return nil, err 7592 } 7593 out = append(out, v) 7594 } 7595 return 7596 7597} 7598 7599// deserializeaudienceIntermediateType will accept a map to create a audienceIntermediateType 7600func deserializeAudienceIntermediateType(in interface{}) (t *audienceIntermediateType, err error) { 7601 tmp := &audienceIntermediateType{} 7602 err = tmp.Deserialize(in) 7603 return tmp, err 7604 7605} 7606 7607// deserializeSlice audienceIntermediateType will accept a slice to create a slice of audienceIntermediateType 7608func deserializeSliceAudienceIntermediateType(in []interface{}) (t []*audienceIntermediateType, err error) { 7609 for _, i := range in { 7610 tmp := &audienceIntermediateType{} 7611 err = tmp.Deserialize(i) 7612 if err != nil { 7613 return 7614 } 7615 t = append(t, tmp) 7616 } 7617 return 7618 7619} 7620 7621// serializeaudienceIntermediateType will accept a audienceIntermediateType to create a map 7622func serializeAudienceIntermediateType(t *audienceIntermediateType) (i interface{}, err error) { 7623 i, err = t.Serialize() 7624 return 7625 7626} 7627 7628// serializeSliceaudienceIntermediateType will accept a slice of audienceIntermediateType to create a slice result 7629func serializeSliceAudienceIntermediateType(s []*audienceIntermediateType) (out []interface{}, err error) { 7630 for _, t := range s { 7631 v, err := t.Serialize() 7632 if err != nil { 7633 return nil, err 7634 } 7635 out = append(out, v) 7636 } 7637 return 7638 7639} 7640 7641// deserializedurationIntermediateType will accept a map to create a durationIntermediateType 7642func deserializeDurationIntermediateType(in interface{}) (t *durationIntermediateType, err error) { 7643 tmp := &durationIntermediateType{} 7644 err = tmp.Deserialize(in) 7645 return tmp, err 7646 7647} 7648 7649// deserializeSlice durationIntermediateType will accept a slice to create a slice of durationIntermediateType 7650func deserializeSliceDurationIntermediateType(in []interface{}) (t []*durationIntermediateType, err error) { 7651 for _, i := range in { 7652 tmp := &durationIntermediateType{} 7653 err = tmp.Deserialize(i) 7654 if err != nil { 7655 return 7656 } 7657 t = append(t, tmp) 7658 } 7659 return 7660 7661} 7662 7663// serializedurationIntermediateType will accept a durationIntermediateType to create a map 7664func serializeDurationIntermediateType(t *durationIntermediateType) (i interface{}, err error) { 7665 i, err = t.Serialize() 7666 return 7667 7668} 7669 7670// serializeSlicedurationIntermediateType will accept a slice of durationIntermediateType to create a slice result 7671func serializeSliceDurationIntermediateType(s []*durationIntermediateType) (out []interface{}, err error) { 7672 for _, t := range s { 7673 v, err := t.Serialize() 7674 if err != nil { 7675 return nil, err 7676 } 7677 out = append(out, v) 7678 } 7679 return 7680 7681} 7682 7683// deserializetargetIntermediateType will accept a map to create a targetIntermediateType 7684func deserializeTargetIntermediateType(in interface{}) (t *targetIntermediateType, err error) { 7685 tmp := &targetIntermediateType{} 7686 err = tmp.Deserialize(in) 7687 return tmp, err 7688 7689} 7690 7691// deserializeSlice targetIntermediateType will accept a slice to create a slice of targetIntermediateType 7692func deserializeSliceTargetIntermediateType(in []interface{}) (t []*targetIntermediateType, err error) { 7693 for _, i := range in { 7694 tmp := &targetIntermediateType{} 7695 err = tmp.Deserialize(i) 7696 if err != nil { 7697 return 7698 } 7699 t = append(t, tmp) 7700 } 7701 return 7702 7703} 7704 7705// serializetargetIntermediateType will accept a targetIntermediateType to create a map 7706func serializeTargetIntermediateType(t *targetIntermediateType) (i interface{}, err error) { 7707 i, err = t.Serialize() 7708 return 7709 7710} 7711 7712// serializeSlicetargetIntermediateType will accept a slice of targetIntermediateType to create a slice result 7713func serializeSliceTargetIntermediateType(s []*targetIntermediateType) (out []interface{}, err error) { 7714 for _, t := range s { 7715 v, err := t.Serialize() 7716 if err != nil { 7717 return nil, err 7718 } 7719 out = append(out, v) 7720 } 7721 return 7722 7723} 7724 7725// deserializedeletedIntermediateType will accept a map to create a deletedIntermediateType 7726func deserializeDeletedIntermediateType(in interface{}) (t *deletedIntermediateType, err error) { 7727 tmp := &deletedIntermediateType{} 7728 err = tmp.Deserialize(in) 7729 return tmp, err 7730 7731} 7732 7733// deserializeSlice deletedIntermediateType will accept a slice to create a slice of deletedIntermediateType 7734func deserializeSliceDeletedIntermediateType(in []interface{}) (t []*deletedIntermediateType, err error) { 7735 for _, i := range in { 7736 tmp := &deletedIntermediateType{} 7737 err = tmp.Deserialize(i) 7738 if err != nil { 7739 return 7740 } 7741 t = append(t, tmp) 7742 } 7743 return 7744 7745} 7746 7747// serializedeletedIntermediateType will accept a deletedIntermediateType to create a map 7748func serializeDeletedIntermediateType(t *deletedIntermediateType) (i interface{}, err error) { 7749 i, err = t.Serialize() 7750 return 7751 7752} 7753 7754// serializeSlicedeletedIntermediateType will accept a slice of deletedIntermediateType to create a slice result 7755func serializeSliceDeletedIntermediateType(s []*deletedIntermediateType) (out []interface{}, err error) { 7756 for _, t := range s { 7757 v, err := t.Serialize() 7758 if err != nil { 7759 return nil, err 7760 } 7761 out = append(out, v) 7762 } 7763 return 7764 7765} 7766 7767// deserializeattributedToIntermediateType will accept a map to create a attributedToIntermediateType 7768func deserializeAttributedToIntermediateType(in interface{}) (t *attributedToIntermediateType, err error) { 7769 tmp := &attributedToIntermediateType{} 7770 err = tmp.Deserialize(in) 7771 return tmp, err 7772 7773} 7774 7775// deserializeSlice attributedToIntermediateType will accept a slice to create a slice of attributedToIntermediateType 7776func deserializeSliceAttributedToIntermediateType(in []interface{}) (t []*attributedToIntermediateType, err error) { 7777 for _, i := range in { 7778 tmp := &attributedToIntermediateType{} 7779 err = tmp.Deserialize(i) 7780 if err != nil { 7781 return 7782 } 7783 t = append(t, tmp) 7784 } 7785 return 7786 7787} 7788 7789// serializeattributedToIntermediateType will accept a attributedToIntermediateType to create a map 7790func serializeAttributedToIntermediateType(t *attributedToIntermediateType) (i interface{}, err error) { 7791 i, err = t.Serialize() 7792 return 7793 7794} 7795 7796// serializeSliceattributedToIntermediateType will accept a slice of attributedToIntermediateType to create a slice result 7797func serializeSliceAttributedToIntermediateType(s []*attributedToIntermediateType) (out []interface{}, err error) { 7798 for _, t := range s { 7799 v, err := t.Serialize() 7800 if err != nil { 7801 return nil, err 7802 } 7803 out = append(out, v) 7804 } 7805 return 7806 7807} 7808 7809// deserializesummaryIntermediateType will accept a map to create a summaryIntermediateType 7810func deserializeSummaryIntermediateType(in interface{}) (t *summaryIntermediateType, err error) { 7811 tmp := &summaryIntermediateType{} 7812 err = tmp.Deserialize(in) 7813 return tmp, err 7814 7815} 7816 7817// deserializeSlice summaryIntermediateType will accept a slice to create a slice of summaryIntermediateType 7818func deserializeSliceSummaryIntermediateType(in []interface{}) (t []*summaryIntermediateType, err error) { 7819 for _, i := range in { 7820 tmp := &summaryIntermediateType{} 7821 err = tmp.Deserialize(i) 7822 if err != nil { 7823 return 7824 } 7825 t = append(t, tmp) 7826 } 7827 return 7828 7829} 7830 7831// serializesummaryIntermediateType will accept a summaryIntermediateType to create a map 7832func serializeSummaryIntermediateType(t *summaryIntermediateType) (i interface{}, err error) { 7833 i, err = t.Serialize() 7834 return 7835 7836} 7837 7838// serializeSlicesummaryIntermediateType will accept a slice of summaryIntermediateType to create a slice result 7839func serializeSliceSummaryIntermediateType(s []*summaryIntermediateType) (out []interface{}, err error) { 7840 for _, t := range s { 7841 v, err := t.Serialize() 7842 if err != nil { 7843 return nil, err 7844 } 7845 out = append(out, v) 7846 } 7847 return 7848 7849} 7850 7851// deserializeendpointsIntermediateType will accept a map to create a endpointsIntermediateType 7852func deserializeEndpointsIntermediateType(in interface{}) (t *endpointsIntermediateType, err error) { 7853 tmp := &endpointsIntermediateType{} 7854 err = tmp.Deserialize(in) 7855 return tmp, err 7856 7857} 7858 7859// deserializeSlice endpointsIntermediateType will accept a slice to create a slice of endpointsIntermediateType 7860func deserializeSliceEndpointsIntermediateType(in []interface{}) (t []*endpointsIntermediateType, err error) { 7861 for _, i := range in { 7862 tmp := &endpointsIntermediateType{} 7863 err = tmp.Deserialize(i) 7864 if err != nil { 7865 return 7866 } 7867 t = append(t, tmp) 7868 } 7869 return 7870 7871} 7872 7873// serializeendpointsIntermediateType will accept a endpointsIntermediateType to create a map 7874func serializeEndpointsIntermediateType(t *endpointsIntermediateType) (i interface{}, err error) { 7875 i, err = t.Serialize() 7876 return 7877 7878} 7879 7880// serializeSliceendpointsIntermediateType will accept a slice of endpointsIntermediateType to create a slice result 7881func serializeSliceEndpointsIntermediateType(s []*endpointsIntermediateType) (out []interface{}, err error) { 7882 for _, t := range s { 7883 v, err := t.Serialize() 7884 if err != nil { 7885 return nil, err 7886 } 7887 out = append(out, v) 7888 } 7889 return 7890 7891} 7892 7893// deserializeheightIntermediateType will accept a map to create a heightIntermediateType 7894func deserializeHeightIntermediateType(in interface{}) (t *heightIntermediateType, err error) { 7895 tmp := &heightIntermediateType{} 7896 err = tmp.Deserialize(in) 7897 return tmp, err 7898 7899} 7900 7901// deserializeSlice heightIntermediateType will accept a slice to create a slice of heightIntermediateType 7902func deserializeSliceHeightIntermediateType(in []interface{}) (t []*heightIntermediateType, err error) { 7903 for _, i := range in { 7904 tmp := &heightIntermediateType{} 7905 err = tmp.Deserialize(i) 7906 if err != nil { 7907 return 7908 } 7909 t = append(t, tmp) 7910 } 7911 return 7912 7913} 7914 7915// serializeheightIntermediateType will accept a heightIntermediateType to create a map 7916func serializeHeightIntermediateType(t *heightIntermediateType) (i interface{}, err error) { 7917 i, err = t.Serialize() 7918 return 7919 7920} 7921 7922// serializeSliceheightIntermediateType will accept a slice of heightIntermediateType to create a slice result 7923func serializeSliceHeightIntermediateType(s []*heightIntermediateType) (out []interface{}, err error) { 7924 for _, t := range s { 7925 v, err := t.Serialize() 7926 if err != nil { 7927 return nil, err 7928 } 7929 out = append(out, v) 7930 } 7931 return 7932 7933} 7934 7935// deserializeitemsIntermediateType will accept a map to create a itemsIntermediateType 7936func deserializeItemsIntermediateType(in interface{}) (t *itemsIntermediateType, err error) { 7937 tmp := &itemsIntermediateType{} 7938 err = tmp.Deserialize(in) 7939 return tmp, err 7940 7941} 7942 7943// deserializeSlice itemsIntermediateType will accept a slice to create a slice of itemsIntermediateType 7944func deserializeSliceItemsIntermediateType(in []interface{}) (t []*itemsIntermediateType, err error) { 7945 for _, i := range in { 7946 tmp := &itemsIntermediateType{} 7947 err = tmp.Deserialize(i) 7948 if err != nil { 7949 return 7950 } 7951 t = append(t, tmp) 7952 } 7953 return 7954 7955} 7956 7957// serializeitemsIntermediateType will accept a itemsIntermediateType to create a map 7958func serializeItemsIntermediateType(t *itemsIntermediateType) (i interface{}, err error) { 7959 i, err = t.Serialize() 7960 return 7961 7962} 7963 7964// serializeSliceitemsIntermediateType will accept a slice of itemsIntermediateType to create a slice result 7965func serializeSliceItemsIntermediateType(s []*itemsIntermediateType) (out []interface{}, err error) { 7966 for _, t := range s { 7967 v, err := t.Serialize() 7968 if err != nil { 7969 return nil, err 7970 } 7971 out = append(out, v) 7972 } 7973 return 7974 7975} 7976