foxwitch.net
1// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
2
3package tangled
4
5import (
6 "fmt"
7 "io"
8 "math"
9 "sort"
10
11 util "github.com/bluesky-social/indigo/lex/util"
12 cid "github.com/ipfs/go-cid"
13 cbg "github.com/whyrusleeping/cbor-gen"
14 xerrors "golang.org/x/xerrors"
15)
16
17var _ = xerrors.Errorf
18var _ = cid.Undef
19var _ = math.E
20var _ = sort.Sort
21
22func (t *ActorProfile) MarshalCBOR(w io.Writer) error {
23 if t == nil {
24 _, err := w.Write(cbg.CborNull)
25 return err
26 }
27
28 cw := cbg.NewCborWriter(w)
29 fieldCount := 7
30
31 if t.Description == nil {
32 fieldCount--
33 }
34
35 if t.Links == nil {
36 fieldCount--
37 }
38
39 if t.Location == nil {
40 fieldCount--
41 }
42
43 if t.PinnedRepositories == nil {
44 fieldCount--
45 }
46
47 if t.Stats == nil {
48 fieldCount--
49 }
50
51 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
52 return err
53 }
54
55 // t.LexiconTypeID (string) (string)
56 if len("$type") > 1000000 {
57 return xerrors.Errorf("Value in field \"$type\" was too long")
58 }
59
60 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
61 return err
62 }
63 if _, err := cw.WriteString(string("$type")); err != nil {
64 return err
65 }
66
67 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.actor.profile"))); err != nil {
68 return err
69 }
70 if _, err := cw.WriteString(string("sh.tangled.actor.profile")); err != nil {
71 return err
72 }
73
74 // t.Links ([]string) (slice)
75 if t.Links != nil {
76
77 if len("links") > 1000000 {
78 return xerrors.Errorf("Value in field \"links\" was too long")
79 }
80
81 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("links"))); err != nil {
82 return err
83 }
84 if _, err := cw.WriteString(string("links")); err != nil {
85 return err
86 }
87
88 if len(t.Links) > 8192 {
89 return xerrors.Errorf("Slice value in field t.Links was too long")
90 }
91
92 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Links))); err != nil {
93 return err
94 }
95 for _, v := range t.Links {
96 if len(v) > 1000000 {
97 return xerrors.Errorf("Value in field v was too long")
98 }
99
100 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
101 return err
102 }
103 if _, err := cw.WriteString(string(v)); err != nil {
104 return err
105 }
106
107 }
108 }
109
110 // t.Stats ([]string) (slice)
111 if t.Stats != nil {
112
113 if len("stats") > 1000000 {
114 return xerrors.Errorf("Value in field \"stats\" was too long")
115 }
116
117 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("stats"))); err != nil {
118 return err
119 }
120 if _, err := cw.WriteString(string("stats")); err != nil {
121 return err
122 }
123
124 if len(t.Stats) > 8192 {
125 return xerrors.Errorf("Slice value in field t.Stats was too long")
126 }
127
128 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Stats))); err != nil {
129 return err
130 }
131 for _, v := range t.Stats {
132 if len(v) > 1000000 {
133 return xerrors.Errorf("Value in field v was too long")
134 }
135
136 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
137 return err
138 }
139 if _, err := cw.WriteString(string(v)); err != nil {
140 return err
141 }
142
143 }
144 }
145
146 // t.Bluesky (bool) (bool)
147 if len("bluesky") > 1000000 {
148 return xerrors.Errorf("Value in field \"bluesky\" was too long")
149 }
150
151 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("bluesky"))); err != nil {
152 return err
153 }
154 if _, err := cw.WriteString(string("bluesky")); err != nil {
155 return err
156 }
157
158 if err := cbg.WriteBool(w, t.Bluesky); err != nil {
159 return err
160 }
161
162 // t.Location (string) (string)
163 if t.Location != nil {
164
165 if len("location") > 1000000 {
166 return xerrors.Errorf("Value in field \"location\" was too long")
167 }
168
169 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("location"))); err != nil {
170 return err
171 }
172 if _, err := cw.WriteString(string("location")); err != nil {
173 return err
174 }
175
176 if t.Location == nil {
177 if _, err := cw.Write(cbg.CborNull); err != nil {
178 return err
179 }
180 } else {
181 if len(*t.Location) > 1000000 {
182 return xerrors.Errorf("Value in field t.Location was too long")
183 }
184
185 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Location))); err != nil {
186 return err
187 }
188 if _, err := cw.WriteString(string(*t.Location)); err != nil {
189 return err
190 }
191 }
192 }
193
194 // t.Description (string) (string)
195 if t.Description != nil {
196
197 if len("description") > 1000000 {
198 return xerrors.Errorf("Value in field \"description\" was too long")
199 }
200
201 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
202 return err
203 }
204 if _, err := cw.WriteString(string("description")); err != nil {
205 return err
206 }
207
208 if t.Description == nil {
209 if _, err := cw.Write(cbg.CborNull); err != nil {
210 return err
211 }
212 } else {
213 if len(*t.Description) > 1000000 {
214 return xerrors.Errorf("Value in field t.Description was too long")
215 }
216
217 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
218 return err
219 }
220 if _, err := cw.WriteString(string(*t.Description)); err != nil {
221 return err
222 }
223 }
224 }
225
226 // t.PinnedRepositories ([]string) (slice)
227 if t.PinnedRepositories != nil {
228
229 if len("pinnedRepositories") > 1000000 {
230 return xerrors.Errorf("Value in field \"pinnedRepositories\" was too long")
231 }
232
233 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pinnedRepositories"))); err != nil {
234 return err
235 }
236 if _, err := cw.WriteString(string("pinnedRepositories")); err != nil {
237 return err
238 }
239
240 if len(t.PinnedRepositories) > 8192 {
241 return xerrors.Errorf("Slice value in field t.PinnedRepositories was too long")
242 }
243
244 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.PinnedRepositories))); err != nil {
245 return err
246 }
247 for _, v := range t.PinnedRepositories {
248 if len(v) > 1000000 {
249 return xerrors.Errorf("Value in field v was too long")
250 }
251
252 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
253 return err
254 }
255 if _, err := cw.WriteString(string(v)); err != nil {
256 return err
257 }
258
259 }
260 }
261 return nil
262}
263
264func (t *ActorProfile) UnmarshalCBOR(r io.Reader) (err error) {
265 *t = ActorProfile{}
266
267 cr := cbg.NewCborReader(r)
268
269 maj, extra, err := cr.ReadHeader()
270 if err != nil {
271 return err
272 }
273 defer func() {
274 if err == io.EOF {
275 err = io.ErrUnexpectedEOF
276 }
277 }()
278
279 if maj != cbg.MajMap {
280 return fmt.Errorf("cbor input should be of type map")
281 }
282
283 if extra > cbg.MaxLength {
284 return fmt.Errorf("ActorProfile: map struct too large (%d)", extra)
285 }
286
287 n := extra
288
289 nameBuf := make([]byte, 18)
290 for i := uint64(0); i < n; i++ {
291 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
292 if err != nil {
293 return err
294 }
295
296 if !ok {
297 // Field doesn't exist on this type, so ignore it
298 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
299 return err
300 }
301 continue
302 }
303
304 switch string(nameBuf[:nameLen]) {
305 // t.LexiconTypeID (string) (string)
306 case "$type":
307
308 {
309 sval, err := cbg.ReadStringWithMax(cr, 1000000)
310 if err != nil {
311 return err
312 }
313
314 t.LexiconTypeID = string(sval)
315 }
316 // t.Links ([]string) (slice)
317 case "links":
318
319 maj, extra, err = cr.ReadHeader()
320 if err != nil {
321 return err
322 }
323
324 if extra > 8192 {
325 return fmt.Errorf("t.Links: array too large (%d)", extra)
326 }
327
328 if maj != cbg.MajArray {
329 return fmt.Errorf("expected cbor array")
330 }
331
332 if extra > 0 {
333 t.Links = make([]string, extra)
334 }
335
336 for i := 0; i < int(extra); i++ {
337 {
338 var maj byte
339 var extra uint64
340 var err error
341 _ = maj
342 _ = extra
343 _ = err
344
345 {
346 sval, err := cbg.ReadStringWithMax(cr, 1000000)
347 if err != nil {
348 return err
349 }
350
351 t.Links[i] = string(sval)
352 }
353
354 }
355 }
356 // t.Stats ([]string) (slice)
357 case "stats":
358
359 maj, extra, err = cr.ReadHeader()
360 if err != nil {
361 return err
362 }
363
364 if extra > 8192 {
365 return fmt.Errorf("t.Stats: array too large (%d)", extra)
366 }
367
368 if maj != cbg.MajArray {
369 return fmt.Errorf("expected cbor array")
370 }
371
372 if extra > 0 {
373 t.Stats = make([]string, extra)
374 }
375
376 for i := 0; i < int(extra); i++ {
377 {
378 var maj byte
379 var extra uint64
380 var err error
381 _ = maj
382 _ = extra
383 _ = err
384
385 {
386 sval, err := cbg.ReadStringWithMax(cr, 1000000)
387 if err != nil {
388 return err
389 }
390
391 t.Stats[i] = string(sval)
392 }
393
394 }
395 }
396 // t.Bluesky (bool) (bool)
397 case "bluesky":
398
399 maj, extra, err = cr.ReadHeader()
400 if err != nil {
401 return err
402 }
403 if maj != cbg.MajOther {
404 return fmt.Errorf("booleans must be major type 7")
405 }
406 switch extra {
407 case 20:
408 t.Bluesky = false
409 case 21:
410 t.Bluesky = true
411 default:
412 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
413 }
414 // t.Location (string) (string)
415 case "location":
416
417 {
418 b, err := cr.ReadByte()
419 if err != nil {
420 return err
421 }
422 if b != cbg.CborNull[0] {
423 if err := cr.UnreadByte(); err != nil {
424 return err
425 }
426
427 sval, err := cbg.ReadStringWithMax(cr, 1000000)
428 if err != nil {
429 return err
430 }
431
432 t.Location = (*string)(&sval)
433 }
434 }
435 // t.Description (string) (string)
436 case "description":
437
438 {
439 b, err := cr.ReadByte()
440 if err != nil {
441 return err
442 }
443 if b != cbg.CborNull[0] {
444 if err := cr.UnreadByte(); err != nil {
445 return err
446 }
447
448 sval, err := cbg.ReadStringWithMax(cr, 1000000)
449 if err != nil {
450 return err
451 }
452
453 t.Description = (*string)(&sval)
454 }
455 }
456 // t.PinnedRepositories ([]string) (slice)
457 case "pinnedRepositories":
458
459 maj, extra, err = cr.ReadHeader()
460 if err != nil {
461 return err
462 }
463
464 if extra > 8192 {
465 return fmt.Errorf("t.PinnedRepositories: array too large (%d)", extra)
466 }
467
468 if maj != cbg.MajArray {
469 return fmt.Errorf("expected cbor array")
470 }
471
472 if extra > 0 {
473 t.PinnedRepositories = make([]string, extra)
474 }
475
476 for i := 0; i < int(extra); i++ {
477 {
478 var maj byte
479 var extra uint64
480 var err error
481 _ = maj
482 _ = extra
483 _ = err
484
485 {
486 sval, err := cbg.ReadStringWithMax(cr, 1000000)
487 if err != nil {
488 return err
489 }
490
491 t.PinnedRepositories[i] = string(sval)
492 }
493
494 }
495 }
496
497 default:
498 // Field doesn't exist on this type, so ignore it
499 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
500 return err
501 }
502 }
503 }
504
505 return nil
506}
507func (t *FeedReaction) MarshalCBOR(w io.Writer) error {
508 if t == nil {
509 _, err := w.Write(cbg.CborNull)
510 return err
511 }
512
513 cw := cbg.NewCborWriter(w)
514
515 if _, err := cw.Write([]byte{164}); err != nil {
516 return err
517 }
518
519 // t.LexiconTypeID (string) (string)
520 if len("$type") > 1000000 {
521 return xerrors.Errorf("Value in field \"$type\" was too long")
522 }
523
524 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
525 return err
526 }
527 if _, err := cw.WriteString(string("$type")); err != nil {
528 return err
529 }
530
531 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.reaction"))); err != nil {
532 return err
533 }
534 if _, err := cw.WriteString(string("sh.tangled.feed.reaction")); err != nil {
535 return err
536 }
537
538 // t.Subject (string) (string)
539 if len("subject") > 1000000 {
540 return xerrors.Errorf("Value in field \"subject\" was too long")
541 }
542
543 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
544 return err
545 }
546 if _, err := cw.WriteString(string("subject")); err != nil {
547 return err
548 }
549
550 if len(t.Subject) > 1000000 {
551 return xerrors.Errorf("Value in field t.Subject was too long")
552 }
553
554 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
555 return err
556 }
557 if _, err := cw.WriteString(string(t.Subject)); err != nil {
558 return err
559 }
560
561 // t.Reaction (string) (string)
562 if len("reaction") > 1000000 {
563 return xerrors.Errorf("Value in field \"reaction\" was too long")
564 }
565
566 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("reaction"))); err != nil {
567 return err
568 }
569 if _, err := cw.WriteString(string("reaction")); err != nil {
570 return err
571 }
572
573 if len(t.Reaction) > 1000000 {
574 return xerrors.Errorf("Value in field t.Reaction was too long")
575 }
576
577 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Reaction))); err != nil {
578 return err
579 }
580 if _, err := cw.WriteString(string(t.Reaction)); err != nil {
581 return err
582 }
583
584 // t.CreatedAt (string) (string)
585 if len("createdAt") > 1000000 {
586 return xerrors.Errorf("Value in field \"createdAt\" was too long")
587 }
588
589 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
590 return err
591 }
592 if _, err := cw.WriteString(string("createdAt")); err != nil {
593 return err
594 }
595
596 if len(t.CreatedAt) > 1000000 {
597 return xerrors.Errorf("Value in field t.CreatedAt was too long")
598 }
599
600 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
601 return err
602 }
603 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
604 return err
605 }
606 return nil
607}
608
609func (t *FeedReaction) UnmarshalCBOR(r io.Reader) (err error) {
610 *t = FeedReaction{}
611
612 cr := cbg.NewCborReader(r)
613
614 maj, extra, err := cr.ReadHeader()
615 if err != nil {
616 return err
617 }
618 defer func() {
619 if err == io.EOF {
620 err = io.ErrUnexpectedEOF
621 }
622 }()
623
624 if maj != cbg.MajMap {
625 return fmt.Errorf("cbor input should be of type map")
626 }
627
628 if extra > cbg.MaxLength {
629 return fmt.Errorf("FeedReaction: map struct too large (%d)", extra)
630 }
631
632 n := extra
633
634 nameBuf := make([]byte, 9)
635 for i := uint64(0); i < n; i++ {
636 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
637 if err != nil {
638 return err
639 }
640
641 if !ok {
642 // Field doesn't exist on this type, so ignore it
643 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
644 return err
645 }
646 continue
647 }
648
649 switch string(nameBuf[:nameLen]) {
650 // t.LexiconTypeID (string) (string)
651 case "$type":
652
653 {
654 sval, err := cbg.ReadStringWithMax(cr, 1000000)
655 if err != nil {
656 return err
657 }
658
659 t.LexiconTypeID = string(sval)
660 }
661 // t.Subject (string) (string)
662 case "subject":
663
664 {
665 sval, err := cbg.ReadStringWithMax(cr, 1000000)
666 if err != nil {
667 return err
668 }
669
670 t.Subject = string(sval)
671 }
672 // t.Reaction (string) (string)
673 case "reaction":
674
675 {
676 sval, err := cbg.ReadStringWithMax(cr, 1000000)
677 if err != nil {
678 return err
679 }
680
681 t.Reaction = string(sval)
682 }
683 // t.CreatedAt (string) (string)
684 case "createdAt":
685
686 {
687 sval, err := cbg.ReadStringWithMax(cr, 1000000)
688 if err != nil {
689 return err
690 }
691
692 t.CreatedAt = string(sval)
693 }
694
695 default:
696 // Field doesn't exist on this type, so ignore it
697 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
698 return err
699 }
700 }
701 }
702
703 return nil
704}
705func (t *FeedStar) MarshalCBOR(w io.Writer) error {
706 if t == nil {
707 _, err := w.Write(cbg.CborNull)
708 return err
709 }
710
711 cw := cbg.NewCborWriter(w)
712
713 if _, err := cw.Write([]byte{163}); err != nil {
714 return err
715 }
716
717 // t.LexiconTypeID (string) (string)
718 if len("$type") > 1000000 {
719 return xerrors.Errorf("Value in field \"$type\" was too long")
720 }
721
722 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
723 return err
724 }
725 if _, err := cw.WriteString(string("$type")); err != nil {
726 return err
727 }
728
729 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.star"))); err != nil {
730 return err
731 }
732 if _, err := cw.WriteString(string("sh.tangled.feed.star")); err != nil {
733 return err
734 }
735
736 // t.Subject (string) (string)
737 if len("subject") > 1000000 {
738 return xerrors.Errorf("Value in field \"subject\" was too long")
739 }
740
741 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
742 return err
743 }
744 if _, err := cw.WriteString(string("subject")); err != nil {
745 return err
746 }
747
748 if len(t.Subject) > 1000000 {
749 return xerrors.Errorf("Value in field t.Subject was too long")
750 }
751
752 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
753 return err
754 }
755 if _, err := cw.WriteString(string(t.Subject)); err != nil {
756 return err
757 }
758
759 // t.CreatedAt (string) (string)
760 if len("createdAt") > 1000000 {
761 return xerrors.Errorf("Value in field \"createdAt\" was too long")
762 }
763
764 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
765 return err
766 }
767 if _, err := cw.WriteString(string("createdAt")); err != nil {
768 return err
769 }
770
771 if len(t.CreatedAt) > 1000000 {
772 return xerrors.Errorf("Value in field t.CreatedAt was too long")
773 }
774
775 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
776 return err
777 }
778 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
779 return err
780 }
781 return nil
782}
783
784func (t *FeedStar) UnmarshalCBOR(r io.Reader) (err error) {
785 *t = FeedStar{}
786
787 cr := cbg.NewCborReader(r)
788
789 maj, extra, err := cr.ReadHeader()
790 if err != nil {
791 return err
792 }
793 defer func() {
794 if err == io.EOF {
795 err = io.ErrUnexpectedEOF
796 }
797 }()
798
799 if maj != cbg.MajMap {
800 return fmt.Errorf("cbor input should be of type map")
801 }
802
803 if extra > cbg.MaxLength {
804 return fmt.Errorf("FeedStar: map struct too large (%d)", extra)
805 }
806
807 n := extra
808
809 nameBuf := make([]byte, 9)
810 for i := uint64(0); i < n; i++ {
811 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
812 if err != nil {
813 return err
814 }
815
816 if !ok {
817 // Field doesn't exist on this type, so ignore it
818 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
819 return err
820 }
821 continue
822 }
823
824 switch string(nameBuf[:nameLen]) {
825 // t.LexiconTypeID (string) (string)
826 case "$type":
827
828 {
829 sval, err := cbg.ReadStringWithMax(cr, 1000000)
830 if err != nil {
831 return err
832 }
833
834 t.LexiconTypeID = string(sval)
835 }
836 // t.Subject (string) (string)
837 case "subject":
838
839 {
840 sval, err := cbg.ReadStringWithMax(cr, 1000000)
841 if err != nil {
842 return err
843 }
844
845 t.Subject = string(sval)
846 }
847 // t.CreatedAt (string) (string)
848 case "createdAt":
849
850 {
851 sval, err := cbg.ReadStringWithMax(cr, 1000000)
852 if err != nil {
853 return err
854 }
855
856 t.CreatedAt = string(sval)
857 }
858
859 default:
860 // Field doesn't exist on this type, so ignore it
861 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
862 return err
863 }
864 }
865 }
866
867 return nil
868}
869func (t *GitRefUpdate) MarshalCBOR(w io.Writer) error {
870 if t == nil {
871 _, err := w.Write(cbg.CborNull)
872 return err
873 }
874
875 cw := cbg.NewCborWriter(w)
876
877 if _, err := cw.Write([]byte{168}); err != nil {
878 return err
879 }
880
881 // t.Ref (string) (string)
882 if len("ref") > 1000000 {
883 return xerrors.Errorf("Value in field \"ref\" was too long")
884 }
885
886 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
887 return err
888 }
889 if _, err := cw.WriteString(string("ref")); err != nil {
890 return err
891 }
892
893 if len(t.Ref) > 1000000 {
894 return xerrors.Errorf("Value in field t.Ref was too long")
895 }
896
897 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
898 return err
899 }
900 if _, err := cw.WriteString(string(t.Ref)); err != nil {
901 return err
902 }
903
904 // t.Meta (tangled.GitRefUpdate_Meta) (struct)
905 if len("meta") > 1000000 {
906 return xerrors.Errorf("Value in field \"meta\" was too long")
907 }
908
909 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil {
910 return err
911 }
912 if _, err := cw.WriteString(string("meta")); err != nil {
913 return err
914 }
915
916 if err := t.Meta.MarshalCBOR(cw); err != nil {
917 return err
918 }
919
920 // t.LexiconTypeID (string) (string)
921 if len("$type") > 1000000 {
922 return xerrors.Errorf("Value in field \"$type\" was too long")
923 }
924
925 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
926 return err
927 }
928 if _, err := cw.WriteString(string("$type")); err != nil {
929 return err
930 }
931
932 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.git.refUpdate"))); err != nil {
933 return err
934 }
935 if _, err := cw.WriteString(string("sh.tangled.git.refUpdate")); err != nil {
936 return err
937 }
938
939 // t.NewSha (string) (string)
940 if len("newSha") > 1000000 {
941 return xerrors.Errorf("Value in field \"newSha\" was too long")
942 }
943
944 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
945 return err
946 }
947 if _, err := cw.WriteString(string("newSha")); err != nil {
948 return err
949 }
950
951 if len(t.NewSha) > 1000000 {
952 return xerrors.Errorf("Value in field t.NewSha was too long")
953 }
954
955 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
956 return err
957 }
958 if _, err := cw.WriteString(string(t.NewSha)); err != nil {
959 return err
960 }
961
962 // t.OldSha (string) (string)
963 if len("oldSha") > 1000000 {
964 return xerrors.Errorf("Value in field \"oldSha\" was too long")
965 }
966
967 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
968 return err
969 }
970 if _, err := cw.WriteString(string("oldSha")); err != nil {
971 return err
972 }
973
974 if len(t.OldSha) > 1000000 {
975 return xerrors.Errorf("Value in field t.OldSha was too long")
976 }
977
978 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
979 return err
980 }
981 if _, err := cw.WriteString(string(t.OldSha)); err != nil {
982 return err
983 }
984
985 // t.RepoDid (string) (string)
986 if len("repoDid") > 1000000 {
987 return xerrors.Errorf("Value in field \"repoDid\" was too long")
988 }
989
990 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
991 return err
992 }
993 if _, err := cw.WriteString(string("repoDid")); err != nil {
994 return err
995 }
996
997 if len(t.RepoDid) > 1000000 {
998 return xerrors.Errorf("Value in field t.RepoDid was too long")
999 }
1000
1001 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoDid))); err != nil {
1002 return err
1003 }
1004 if _, err := cw.WriteString(string(t.RepoDid)); err != nil {
1005 return err
1006 }
1007
1008 // t.RepoName (string) (string)
1009 if len("repoName") > 1000000 {
1010 return xerrors.Errorf("Value in field \"repoName\" was too long")
1011 }
1012
1013 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoName"))); err != nil {
1014 return err
1015 }
1016 if _, err := cw.WriteString(string("repoName")); err != nil {
1017 return err
1018 }
1019
1020 if len(t.RepoName) > 1000000 {
1021 return xerrors.Errorf("Value in field t.RepoName was too long")
1022 }
1023
1024 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoName))); err != nil {
1025 return err
1026 }
1027 if _, err := cw.WriteString(string(t.RepoName)); err != nil {
1028 return err
1029 }
1030
1031 // t.CommitterDid (string) (string)
1032 if len("committerDid") > 1000000 {
1033 return xerrors.Errorf("Value in field \"committerDid\" was too long")
1034 }
1035
1036 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("committerDid"))); err != nil {
1037 return err
1038 }
1039 if _, err := cw.WriteString(string("committerDid")); err != nil {
1040 return err
1041 }
1042
1043 if len(t.CommitterDid) > 1000000 {
1044 return xerrors.Errorf("Value in field t.CommitterDid was too long")
1045 }
1046
1047 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CommitterDid))); err != nil {
1048 return err
1049 }
1050 if _, err := cw.WriteString(string(t.CommitterDid)); err != nil {
1051 return err
1052 }
1053 return nil
1054}
1055
1056func (t *GitRefUpdate) UnmarshalCBOR(r io.Reader) (err error) {
1057 *t = GitRefUpdate{}
1058
1059 cr := cbg.NewCborReader(r)
1060
1061 maj, extra, err := cr.ReadHeader()
1062 if err != nil {
1063 return err
1064 }
1065 defer func() {
1066 if err == io.EOF {
1067 err = io.ErrUnexpectedEOF
1068 }
1069 }()
1070
1071 if maj != cbg.MajMap {
1072 return fmt.Errorf("cbor input should be of type map")
1073 }
1074
1075 if extra > cbg.MaxLength {
1076 return fmt.Errorf("GitRefUpdate: map struct too large (%d)", extra)
1077 }
1078
1079 n := extra
1080
1081 nameBuf := make([]byte, 12)
1082 for i := uint64(0); i < n; i++ {
1083 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1084 if err != nil {
1085 return err
1086 }
1087
1088 if !ok {
1089 // Field doesn't exist on this type, so ignore it
1090 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1091 return err
1092 }
1093 continue
1094 }
1095
1096 switch string(nameBuf[:nameLen]) {
1097 // t.Ref (string) (string)
1098 case "ref":
1099
1100 {
1101 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1102 if err != nil {
1103 return err
1104 }
1105
1106 t.Ref = string(sval)
1107 }
1108 // t.Meta (tangled.GitRefUpdate_Meta) (struct)
1109 case "meta":
1110
1111 {
1112
1113 b, err := cr.ReadByte()
1114 if err != nil {
1115 return err
1116 }
1117 if b != cbg.CborNull[0] {
1118 if err := cr.UnreadByte(); err != nil {
1119 return err
1120 }
1121 t.Meta = new(GitRefUpdate_Meta)
1122 if err := t.Meta.UnmarshalCBOR(cr); err != nil {
1123 return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err)
1124 }
1125 }
1126
1127 }
1128 // t.LexiconTypeID (string) (string)
1129 case "$type":
1130
1131 {
1132 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1133 if err != nil {
1134 return err
1135 }
1136
1137 t.LexiconTypeID = string(sval)
1138 }
1139 // t.NewSha (string) (string)
1140 case "newSha":
1141
1142 {
1143 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1144 if err != nil {
1145 return err
1146 }
1147
1148 t.NewSha = string(sval)
1149 }
1150 // t.OldSha (string) (string)
1151 case "oldSha":
1152
1153 {
1154 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1155 if err != nil {
1156 return err
1157 }
1158
1159 t.OldSha = string(sval)
1160 }
1161 // t.RepoDid (string) (string)
1162 case "repoDid":
1163
1164 {
1165 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1166 if err != nil {
1167 return err
1168 }
1169
1170 t.RepoDid = string(sval)
1171 }
1172 // t.RepoName (string) (string)
1173 case "repoName":
1174
1175 {
1176 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1177 if err != nil {
1178 return err
1179 }
1180
1181 t.RepoName = string(sval)
1182 }
1183 // t.CommitterDid (string) (string)
1184 case "committerDid":
1185
1186 {
1187 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1188 if err != nil {
1189 return err
1190 }
1191
1192 t.CommitterDid = string(sval)
1193 }
1194
1195 default:
1196 // Field doesn't exist on this type, so ignore it
1197 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1198 return err
1199 }
1200 }
1201 }
1202
1203 return nil
1204}
1205func (t *GitRefUpdate_CommitCountBreakdown) MarshalCBOR(w io.Writer) error {
1206 if t == nil {
1207 _, err := w.Write(cbg.CborNull)
1208 return err
1209 }
1210
1211 cw := cbg.NewCborWriter(w)
1212 fieldCount := 1
1213
1214 if t.ByEmail == nil {
1215 fieldCount--
1216 }
1217
1218 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1219 return err
1220 }
1221
1222 // t.ByEmail ([]*tangled.GitRefUpdate_IndividualEmailCommitCount) (slice)
1223 if t.ByEmail != nil {
1224
1225 if len("byEmail") > 1000000 {
1226 return xerrors.Errorf("Value in field \"byEmail\" was too long")
1227 }
1228
1229 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byEmail"))); err != nil {
1230 return err
1231 }
1232 if _, err := cw.WriteString(string("byEmail")); err != nil {
1233 return err
1234 }
1235
1236 if len(t.ByEmail) > 8192 {
1237 return xerrors.Errorf("Slice value in field t.ByEmail was too long")
1238 }
1239
1240 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ByEmail))); err != nil {
1241 return err
1242 }
1243 for _, v := range t.ByEmail {
1244 if err := v.MarshalCBOR(cw); err != nil {
1245 return err
1246 }
1247
1248 }
1249 }
1250 return nil
1251}
1252
1253func (t *GitRefUpdate_CommitCountBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
1254 *t = GitRefUpdate_CommitCountBreakdown{}
1255
1256 cr := cbg.NewCborReader(r)
1257
1258 maj, extra, err := cr.ReadHeader()
1259 if err != nil {
1260 return err
1261 }
1262 defer func() {
1263 if err == io.EOF {
1264 err = io.ErrUnexpectedEOF
1265 }
1266 }()
1267
1268 if maj != cbg.MajMap {
1269 return fmt.Errorf("cbor input should be of type map")
1270 }
1271
1272 if extra > cbg.MaxLength {
1273 return fmt.Errorf("GitRefUpdate_CommitCountBreakdown: map struct too large (%d)", extra)
1274 }
1275
1276 n := extra
1277
1278 nameBuf := make([]byte, 7)
1279 for i := uint64(0); i < n; i++ {
1280 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1281 if err != nil {
1282 return err
1283 }
1284
1285 if !ok {
1286 // Field doesn't exist on this type, so ignore it
1287 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1288 return err
1289 }
1290 continue
1291 }
1292
1293 switch string(nameBuf[:nameLen]) {
1294 // t.ByEmail ([]*tangled.GitRefUpdate_IndividualEmailCommitCount) (slice)
1295 case "byEmail":
1296
1297 maj, extra, err = cr.ReadHeader()
1298 if err != nil {
1299 return err
1300 }
1301
1302 if extra > 8192 {
1303 return fmt.Errorf("t.ByEmail: array too large (%d)", extra)
1304 }
1305
1306 if maj != cbg.MajArray {
1307 return fmt.Errorf("expected cbor array")
1308 }
1309
1310 if extra > 0 {
1311 t.ByEmail = make([]*GitRefUpdate_IndividualEmailCommitCount, extra)
1312 }
1313
1314 for i := 0; i < int(extra); i++ {
1315 {
1316 var maj byte
1317 var extra uint64
1318 var err error
1319 _ = maj
1320 _ = extra
1321 _ = err
1322
1323 {
1324
1325 b, err := cr.ReadByte()
1326 if err != nil {
1327 return err
1328 }
1329 if b != cbg.CborNull[0] {
1330 if err := cr.UnreadByte(); err != nil {
1331 return err
1332 }
1333 t.ByEmail[i] = new(GitRefUpdate_IndividualEmailCommitCount)
1334 if err := t.ByEmail[i].UnmarshalCBOR(cr); err != nil {
1335 return xerrors.Errorf("unmarshaling t.ByEmail[i] pointer: %w", err)
1336 }
1337 }
1338
1339 }
1340
1341 }
1342 }
1343
1344 default:
1345 // Field doesn't exist on this type, so ignore it
1346 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1347 return err
1348 }
1349 }
1350 }
1351
1352 return nil
1353}
1354func (t *GitRefUpdate_IndividualEmailCommitCount) MarshalCBOR(w io.Writer) error {
1355 if t == nil {
1356 _, err := w.Write(cbg.CborNull)
1357 return err
1358 }
1359
1360 cw := cbg.NewCborWriter(w)
1361
1362 if _, err := cw.Write([]byte{162}); err != nil {
1363 return err
1364 }
1365
1366 // t.Count (int64) (int64)
1367 if len("count") > 1000000 {
1368 return xerrors.Errorf("Value in field \"count\" was too long")
1369 }
1370
1371 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("count"))); err != nil {
1372 return err
1373 }
1374 if _, err := cw.WriteString(string("count")); err != nil {
1375 return err
1376 }
1377
1378 if t.Count >= 0 {
1379 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Count)); err != nil {
1380 return err
1381 }
1382 } else {
1383 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Count-1)); err != nil {
1384 return err
1385 }
1386 }
1387
1388 // t.Email (string) (string)
1389 if len("email") > 1000000 {
1390 return xerrors.Errorf("Value in field \"email\" was too long")
1391 }
1392
1393 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("email"))); err != nil {
1394 return err
1395 }
1396 if _, err := cw.WriteString(string("email")); err != nil {
1397 return err
1398 }
1399
1400 if len(t.Email) > 1000000 {
1401 return xerrors.Errorf("Value in field t.Email was too long")
1402 }
1403
1404 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Email))); err != nil {
1405 return err
1406 }
1407 if _, err := cw.WriteString(string(t.Email)); err != nil {
1408 return err
1409 }
1410 return nil
1411}
1412
1413func (t *GitRefUpdate_IndividualEmailCommitCount) UnmarshalCBOR(r io.Reader) (err error) {
1414 *t = GitRefUpdate_IndividualEmailCommitCount{}
1415
1416 cr := cbg.NewCborReader(r)
1417
1418 maj, extra, err := cr.ReadHeader()
1419 if err != nil {
1420 return err
1421 }
1422 defer func() {
1423 if err == io.EOF {
1424 err = io.ErrUnexpectedEOF
1425 }
1426 }()
1427
1428 if maj != cbg.MajMap {
1429 return fmt.Errorf("cbor input should be of type map")
1430 }
1431
1432 if extra > cbg.MaxLength {
1433 return fmt.Errorf("GitRefUpdate_IndividualEmailCommitCount: map struct too large (%d)", extra)
1434 }
1435
1436 n := extra
1437
1438 nameBuf := make([]byte, 5)
1439 for i := uint64(0); i < n; i++ {
1440 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1441 if err != nil {
1442 return err
1443 }
1444
1445 if !ok {
1446 // Field doesn't exist on this type, so ignore it
1447 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1448 return err
1449 }
1450 continue
1451 }
1452
1453 switch string(nameBuf[:nameLen]) {
1454 // t.Count (int64) (int64)
1455 case "count":
1456 {
1457 maj, extra, err := cr.ReadHeader()
1458 if err != nil {
1459 return err
1460 }
1461 var extraI int64
1462 switch maj {
1463 case cbg.MajUnsignedInt:
1464 extraI = int64(extra)
1465 if extraI < 0 {
1466 return fmt.Errorf("int64 positive overflow")
1467 }
1468 case cbg.MajNegativeInt:
1469 extraI = int64(extra)
1470 if extraI < 0 {
1471 return fmt.Errorf("int64 negative overflow")
1472 }
1473 extraI = -1 - extraI
1474 default:
1475 return fmt.Errorf("wrong type for int64 field: %d", maj)
1476 }
1477
1478 t.Count = int64(extraI)
1479 }
1480 // t.Email (string) (string)
1481 case "email":
1482
1483 {
1484 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1485 if err != nil {
1486 return err
1487 }
1488
1489 t.Email = string(sval)
1490 }
1491
1492 default:
1493 // Field doesn't exist on this type, so ignore it
1494 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1495 return err
1496 }
1497 }
1498 }
1499
1500 return nil
1501}
1502func (t *GitRefUpdate_IndividualLanguageSize) MarshalCBOR(w io.Writer) error {
1503 if t == nil {
1504 _, err := w.Write(cbg.CborNull)
1505 return err
1506 }
1507
1508 cw := cbg.NewCborWriter(w)
1509
1510 if _, err := cw.Write([]byte{162}); err != nil {
1511 return err
1512 }
1513
1514 // t.Lang (string) (string)
1515 if len("lang") > 1000000 {
1516 return xerrors.Errorf("Value in field \"lang\" was too long")
1517 }
1518
1519 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil {
1520 return err
1521 }
1522 if _, err := cw.WriteString(string("lang")); err != nil {
1523 return err
1524 }
1525
1526 if len(t.Lang) > 1000000 {
1527 return xerrors.Errorf("Value in field t.Lang was too long")
1528 }
1529
1530 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil {
1531 return err
1532 }
1533 if _, err := cw.WriteString(string(t.Lang)); err != nil {
1534 return err
1535 }
1536
1537 // t.Size (int64) (int64)
1538 if len("size") > 1000000 {
1539 return xerrors.Errorf("Value in field \"size\" was too long")
1540 }
1541
1542 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil {
1543 return err
1544 }
1545 if _, err := cw.WriteString(string("size")); err != nil {
1546 return err
1547 }
1548
1549 if t.Size >= 0 {
1550 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil {
1551 return err
1552 }
1553 } else {
1554 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); err != nil {
1555 return err
1556 }
1557 }
1558
1559 return nil
1560}
1561
1562func (t *GitRefUpdate_IndividualLanguageSize) UnmarshalCBOR(r io.Reader) (err error) {
1563 *t = GitRefUpdate_IndividualLanguageSize{}
1564
1565 cr := cbg.NewCborReader(r)
1566
1567 maj, extra, err := cr.ReadHeader()
1568 if err != nil {
1569 return err
1570 }
1571 defer func() {
1572 if err == io.EOF {
1573 err = io.ErrUnexpectedEOF
1574 }
1575 }()
1576
1577 if maj != cbg.MajMap {
1578 return fmt.Errorf("cbor input should be of type map")
1579 }
1580
1581 if extra > cbg.MaxLength {
1582 return fmt.Errorf("GitRefUpdate_IndividualLanguageSize: map struct too large (%d)", extra)
1583 }
1584
1585 n := extra
1586
1587 nameBuf := make([]byte, 4)
1588 for i := uint64(0); i < n; i++ {
1589 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1590 if err != nil {
1591 return err
1592 }
1593
1594 if !ok {
1595 // Field doesn't exist on this type, so ignore it
1596 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1597 return err
1598 }
1599 continue
1600 }
1601
1602 switch string(nameBuf[:nameLen]) {
1603 // t.Lang (string) (string)
1604 case "lang":
1605
1606 {
1607 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1608 if err != nil {
1609 return err
1610 }
1611
1612 t.Lang = string(sval)
1613 }
1614 // t.Size (int64) (int64)
1615 case "size":
1616 {
1617 maj, extra, err := cr.ReadHeader()
1618 if err != nil {
1619 return err
1620 }
1621 var extraI int64
1622 switch maj {
1623 case cbg.MajUnsignedInt:
1624 extraI = int64(extra)
1625 if extraI < 0 {
1626 return fmt.Errorf("int64 positive overflow")
1627 }
1628 case cbg.MajNegativeInt:
1629 extraI = int64(extra)
1630 if extraI < 0 {
1631 return fmt.Errorf("int64 negative overflow")
1632 }
1633 extraI = -1 - extraI
1634 default:
1635 return fmt.Errorf("wrong type for int64 field: %d", maj)
1636 }
1637
1638 t.Size = int64(extraI)
1639 }
1640
1641 default:
1642 // Field doesn't exist on this type, so ignore it
1643 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1644 return err
1645 }
1646 }
1647 }
1648
1649 return nil
1650}
1651func (t *GitRefUpdate_LangBreakdown) MarshalCBOR(w io.Writer) error {
1652 if t == nil {
1653 _, err := w.Write(cbg.CborNull)
1654 return err
1655 }
1656
1657 cw := cbg.NewCborWriter(w)
1658 fieldCount := 1
1659
1660 if t.Inputs == nil {
1661 fieldCount--
1662 }
1663
1664 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1665 return err
1666 }
1667
1668 // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice)
1669 if t.Inputs != nil {
1670
1671 if len("inputs") > 1000000 {
1672 return xerrors.Errorf("Value in field \"inputs\" was too long")
1673 }
1674
1675 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
1676 return err
1677 }
1678 if _, err := cw.WriteString(string("inputs")); err != nil {
1679 return err
1680 }
1681
1682 if len(t.Inputs) > 8192 {
1683 return xerrors.Errorf("Slice value in field t.Inputs was too long")
1684 }
1685
1686 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
1687 return err
1688 }
1689 for _, v := range t.Inputs {
1690 if err := v.MarshalCBOR(cw); err != nil {
1691 return err
1692 }
1693
1694 }
1695 }
1696 return nil
1697}
1698
1699func (t *GitRefUpdate_LangBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
1700 *t = GitRefUpdate_LangBreakdown{}
1701
1702 cr := cbg.NewCborReader(r)
1703
1704 maj, extra, err := cr.ReadHeader()
1705 if err != nil {
1706 return err
1707 }
1708 defer func() {
1709 if err == io.EOF {
1710 err = io.ErrUnexpectedEOF
1711 }
1712 }()
1713
1714 if maj != cbg.MajMap {
1715 return fmt.Errorf("cbor input should be of type map")
1716 }
1717
1718 if extra > cbg.MaxLength {
1719 return fmt.Errorf("GitRefUpdate_LangBreakdown: map struct too large (%d)", extra)
1720 }
1721
1722 n := extra
1723
1724 nameBuf := make([]byte, 6)
1725 for i := uint64(0); i < n; i++ {
1726 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1727 if err != nil {
1728 return err
1729 }
1730
1731 if !ok {
1732 // Field doesn't exist on this type, so ignore it
1733 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1734 return err
1735 }
1736 continue
1737 }
1738
1739 switch string(nameBuf[:nameLen]) {
1740 // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice)
1741 case "inputs":
1742
1743 maj, extra, err = cr.ReadHeader()
1744 if err != nil {
1745 return err
1746 }
1747
1748 if extra > 8192 {
1749 return fmt.Errorf("t.Inputs: array too large (%d)", extra)
1750 }
1751
1752 if maj != cbg.MajArray {
1753 return fmt.Errorf("expected cbor array")
1754 }
1755
1756 if extra > 0 {
1757 t.Inputs = make([]*GitRefUpdate_IndividualLanguageSize, extra)
1758 }
1759
1760 for i := 0; i < int(extra); i++ {
1761 {
1762 var maj byte
1763 var extra uint64
1764 var err error
1765 _ = maj
1766 _ = extra
1767 _ = err
1768
1769 {
1770
1771 b, err := cr.ReadByte()
1772 if err != nil {
1773 return err
1774 }
1775 if b != cbg.CborNull[0] {
1776 if err := cr.UnreadByte(); err != nil {
1777 return err
1778 }
1779 t.Inputs[i] = new(GitRefUpdate_IndividualLanguageSize)
1780 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
1781 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
1782 }
1783 }
1784
1785 }
1786
1787 }
1788 }
1789
1790 default:
1791 // Field doesn't exist on this type, so ignore it
1792 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1793 return err
1794 }
1795 }
1796 }
1797
1798 return nil
1799}
1800func (t *GitRefUpdate_Meta) MarshalCBOR(w io.Writer) error {
1801 if t == nil {
1802 _, err := w.Write(cbg.CborNull)
1803 return err
1804 }
1805
1806 cw := cbg.NewCborWriter(w)
1807 fieldCount := 3
1808
1809 if t.LangBreakdown == nil {
1810 fieldCount--
1811 }
1812
1813 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1814 return err
1815 }
1816
1817 // t.CommitCount (tangled.GitRefUpdate_CommitCountBreakdown) (struct)
1818 if len("commitCount") > 1000000 {
1819 return xerrors.Errorf("Value in field \"commitCount\" was too long")
1820 }
1821
1822 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commitCount"))); err != nil {
1823 return err
1824 }
1825 if _, err := cw.WriteString(string("commitCount")); err != nil {
1826 return err
1827 }
1828
1829 if err := t.CommitCount.MarshalCBOR(cw); err != nil {
1830 return err
1831 }
1832
1833 // t.IsDefaultRef (bool) (bool)
1834 if len("isDefaultRef") > 1000000 {
1835 return xerrors.Errorf("Value in field \"isDefaultRef\" was too long")
1836 }
1837
1838 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("isDefaultRef"))); err != nil {
1839 return err
1840 }
1841 if _, err := cw.WriteString(string("isDefaultRef")); err != nil {
1842 return err
1843 }
1844
1845 if err := cbg.WriteBool(w, t.IsDefaultRef); err != nil {
1846 return err
1847 }
1848
1849 // t.LangBreakdown (tangled.GitRefUpdate_LangBreakdown) (struct)
1850 if t.LangBreakdown != nil {
1851
1852 if len("langBreakdown") > 1000000 {
1853 return xerrors.Errorf("Value in field \"langBreakdown\" was too long")
1854 }
1855
1856 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("langBreakdown"))); err != nil {
1857 return err
1858 }
1859 if _, err := cw.WriteString(string("langBreakdown")); err != nil {
1860 return err
1861 }
1862
1863 if err := t.LangBreakdown.MarshalCBOR(cw); err != nil {
1864 return err
1865 }
1866 }
1867 return nil
1868}
1869
1870func (t *GitRefUpdate_Meta) UnmarshalCBOR(r io.Reader) (err error) {
1871 *t = GitRefUpdate_Meta{}
1872
1873 cr := cbg.NewCborReader(r)
1874
1875 maj, extra, err := cr.ReadHeader()
1876 if err != nil {
1877 return err
1878 }
1879 defer func() {
1880 if err == io.EOF {
1881 err = io.ErrUnexpectedEOF
1882 }
1883 }()
1884
1885 if maj != cbg.MajMap {
1886 return fmt.Errorf("cbor input should be of type map")
1887 }
1888
1889 if extra > cbg.MaxLength {
1890 return fmt.Errorf("GitRefUpdate_Meta: map struct too large (%d)", extra)
1891 }
1892
1893 n := extra
1894
1895 nameBuf := make([]byte, 13)
1896 for i := uint64(0); i < n; i++ {
1897 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1898 if err != nil {
1899 return err
1900 }
1901
1902 if !ok {
1903 // Field doesn't exist on this type, so ignore it
1904 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1905 return err
1906 }
1907 continue
1908 }
1909
1910 switch string(nameBuf[:nameLen]) {
1911 // t.CommitCount (tangled.GitRefUpdate_CommitCountBreakdown) (struct)
1912 case "commitCount":
1913
1914 {
1915
1916 b, err := cr.ReadByte()
1917 if err != nil {
1918 return err
1919 }
1920 if b != cbg.CborNull[0] {
1921 if err := cr.UnreadByte(); err != nil {
1922 return err
1923 }
1924 t.CommitCount = new(GitRefUpdate_CommitCountBreakdown)
1925 if err := t.CommitCount.UnmarshalCBOR(cr); err != nil {
1926 return xerrors.Errorf("unmarshaling t.CommitCount pointer: %w", err)
1927 }
1928 }
1929
1930 }
1931 // t.IsDefaultRef (bool) (bool)
1932 case "isDefaultRef":
1933
1934 maj, extra, err = cr.ReadHeader()
1935 if err != nil {
1936 return err
1937 }
1938 if maj != cbg.MajOther {
1939 return fmt.Errorf("booleans must be major type 7")
1940 }
1941 switch extra {
1942 case 20:
1943 t.IsDefaultRef = false
1944 case 21:
1945 t.IsDefaultRef = true
1946 default:
1947 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
1948 }
1949 // t.LangBreakdown (tangled.GitRefUpdate_LangBreakdown) (struct)
1950 case "langBreakdown":
1951
1952 {
1953
1954 b, err := cr.ReadByte()
1955 if err != nil {
1956 return err
1957 }
1958 if b != cbg.CborNull[0] {
1959 if err := cr.UnreadByte(); err != nil {
1960 return err
1961 }
1962 t.LangBreakdown = new(GitRefUpdate_LangBreakdown)
1963 if err := t.LangBreakdown.UnmarshalCBOR(cr); err != nil {
1964 return xerrors.Errorf("unmarshaling t.LangBreakdown pointer: %w", err)
1965 }
1966 }
1967
1968 }
1969
1970 default:
1971 // Field doesn't exist on this type, so ignore it
1972 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1973 return err
1974 }
1975 }
1976 }
1977
1978 return nil
1979}
1980func (t *GraphFollow) MarshalCBOR(w io.Writer) error {
1981 if t == nil {
1982 _, err := w.Write(cbg.CborNull)
1983 return err
1984 }
1985
1986 cw := cbg.NewCborWriter(w)
1987
1988 if _, err := cw.Write([]byte{163}); err != nil {
1989 return err
1990 }
1991
1992 // t.LexiconTypeID (string) (string)
1993 if len("$type") > 1000000 {
1994 return xerrors.Errorf("Value in field \"$type\" was too long")
1995 }
1996
1997 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
1998 return err
1999 }
2000 if _, err := cw.WriteString(string("$type")); err != nil {
2001 return err
2002 }
2003
2004 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.graph.follow"))); err != nil {
2005 return err
2006 }
2007 if _, err := cw.WriteString(string("sh.tangled.graph.follow")); err != nil {
2008 return err
2009 }
2010
2011 // t.Subject (string) (string)
2012 if len("subject") > 1000000 {
2013 return xerrors.Errorf("Value in field \"subject\" was too long")
2014 }
2015
2016 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
2017 return err
2018 }
2019 if _, err := cw.WriteString(string("subject")); err != nil {
2020 return err
2021 }
2022
2023 if len(t.Subject) > 1000000 {
2024 return xerrors.Errorf("Value in field t.Subject was too long")
2025 }
2026
2027 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
2028 return err
2029 }
2030 if _, err := cw.WriteString(string(t.Subject)); err != nil {
2031 return err
2032 }
2033
2034 // t.CreatedAt (string) (string)
2035 if len("createdAt") > 1000000 {
2036 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2037 }
2038
2039 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2040 return err
2041 }
2042 if _, err := cw.WriteString(string("createdAt")); err != nil {
2043 return err
2044 }
2045
2046 if len(t.CreatedAt) > 1000000 {
2047 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2048 }
2049
2050 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2051 return err
2052 }
2053 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2054 return err
2055 }
2056 return nil
2057}
2058
2059func (t *GraphFollow) UnmarshalCBOR(r io.Reader) (err error) {
2060 *t = GraphFollow{}
2061
2062 cr := cbg.NewCborReader(r)
2063
2064 maj, extra, err := cr.ReadHeader()
2065 if err != nil {
2066 return err
2067 }
2068 defer func() {
2069 if err == io.EOF {
2070 err = io.ErrUnexpectedEOF
2071 }
2072 }()
2073
2074 if maj != cbg.MajMap {
2075 return fmt.Errorf("cbor input should be of type map")
2076 }
2077
2078 if extra > cbg.MaxLength {
2079 return fmt.Errorf("GraphFollow: map struct too large (%d)", extra)
2080 }
2081
2082 n := extra
2083
2084 nameBuf := make([]byte, 9)
2085 for i := uint64(0); i < n; i++ {
2086 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2087 if err != nil {
2088 return err
2089 }
2090
2091 if !ok {
2092 // Field doesn't exist on this type, so ignore it
2093 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2094 return err
2095 }
2096 continue
2097 }
2098
2099 switch string(nameBuf[:nameLen]) {
2100 // t.LexiconTypeID (string) (string)
2101 case "$type":
2102
2103 {
2104 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2105 if err != nil {
2106 return err
2107 }
2108
2109 t.LexiconTypeID = string(sval)
2110 }
2111 // t.Subject (string) (string)
2112 case "subject":
2113
2114 {
2115 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2116 if err != nil {
2117 return err
2118 }
2119
2120 t.Subject = string(sval)
2121 }
2122 // t.CreatedAt (string) (string)
2123 case "createdAt":
2124
2125 {
2126 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2127 if err != nil {
2128 return err
2129 }
2130
2131 t.CreatedAt = string(sval)
2132 }
2133
2134 default:
2135 // Field doesn't exist on this type, so ignore it
2136 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2137 return err
2138 }
2139 }
2140 }
2141
2142 return nil
2143}
2144func (t *Knot) MarshalCBOR(w io.Writer) error {
2145 if t == nil {
2146 _, err := w.Write(cbg.CborNull)
2147 return err
2148 }
2149
2150 cw := cbg.NewCborWriter(w)
2151
2152 if _, err := cw.Write([]byte{162}); err != nil {
2153 return err
2154 }
2155
2156 // t.LexiconTypeID (string) (string)
2157 if len("$type") > 1000000 {
2158 return xerrors.Errorf("Value in field \"$type\" was too long")
2159 }
2160
2161 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2162 return err
2163 }
2164 if _, err := cw.WriteString(string("$type")); err != nil {
2165 return err
2166 }
2167
2168 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot"))); err != nil {
2169 return err
2170 }
2171 if _, err := cw.WriteString(string("sh.tangled.knot")); err != nil {
2172 return err
2173 }
2174
2175 // t.CreatedAt (string) (string)
2176 if len("createdAt") > 1000000 {
2177 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2178 }
2179
2180 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2181 return err
2182 }
2183 if _, err := cw.WriteString(string("createdAt")); err != nil {
2184 return err
2185 }
2186
2187 if len(t.CreatedAt) > 1000000 {
2188 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2189 }
2190
2191 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2192 return err
2193 }
2194 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2195 return err
2196 }
2197 return nil
2198}
2199
2200func (t *Knot) UnmarshalCBOR(r io.Reader) (err error) {
2201 *t = Knot{}
2202
2203 cr := cbg.NewCborReader(r)
2204
2205 maj, extra, err := cr.ReadHeader()
2206 if err != nil {
2207 return err
2208 }
2209 defer func() {
2210 if err == io.EOF {
2211 err = io.ErrUnexpectedEOF
2212 }
2213 }()
2214
2215 if maj != cbg.MajMap {
2216 return fmt.Errorf("cbor input should be of type map")
2217 }
2218
2219 if extra > cbg.MaxLength {
2220 return fmt.Errorf("Knot: map struct too large (%d)", extra)
2221 }
2222
2223 n := extra
2224
2225 nameBuf := make([]byte, 9)
2226 for i := uint64(0); i < n; i++ {
2227 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2228 if err != nil {
2229 return err
2230 }
2231
2232 if !ok {
2233 // Field doesn't exist on this type, so ignore it
2234 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2235 return err
2236 }
2237 continue
2238 }
2239
2240 switch string(nameBuf[:nameLen]) {
2241 // t.LexiconTypeID (string) (string)
2242 case "$type":
2243
2244 {
2245 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2246 if err != nil {
2247 return err
2248 }
2249
2250 t.LexiconTypeID = string(sval)
2251 }
2252 // t.CreatedAt (string) (string)
2253 case "createdAt":
2254
2255 {
2256 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2257 if err != nil {
2258 return err
2259 }
2260
2261 t.CreatedAt = string(sval)
2262 }
2263
2264 default:
2265 // Field doesn't exist on this type, so ignore it
2266 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2267 return err
2268 }
2269 }
2270 }
2271
2272 return nil
2273}
2274func (t *KnotMember) MarshalCBOR(w io.Writer) error {
2275 if t == nil {
2276 _, err := w.Write(cbg.CborNull)
2277 return err
2278 }
2279
2280 cw := cbg.NewCborWriter(w)
2281
2282 if _, err := cw.Write([]byte{164}); err != nil {
2283 return err
2284 }
2285
2286 // t.LexiconTypeID (string) (string)
2287 if len("$type") > 1000000 {
2288 return xerrors.Errorf("Value in field \"$type\" was too long")
2289 }
2290
2291 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2292 return err
2293 }
2294 if _, err := cw.WriteString(string("$type")); err != nil {
2295 return err
2296 }
2297
2298 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot.member"))); err != nil {
2299 return err
2300 }
2301 if _, err := cw.WriteString(string("sh.tangled.knot.member")); err != nil {
2302 return err
2303 }
2304
2305 // t.Domain (string) (string)
2306 if len("domain") > 1000000 {
2307 return xerrors.Errorf("Value in field \"domain\" was too long")
2308 }
2309
2310 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("domain"))); err != nil {
2311 return err
2312 }
2313 if _, err := cw.WriteString(string("domain")); err != nil {
2314 return err
2315 }
2316
2317 if len(t.Domain) > 1000000 {
2318 return xerrors.Errorf("Value in field t.Domain was too long")
2319 }
2320
2321 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Domain))); err != nil {
2322 return err
2323 }
2324 if _, err := cw.WriteString(string(t.Domain)); err != nil {
2325 return err
2326 }
2327
2328 // t.Subject (string) (string)
2329 if len("subject") > 1000000 {
2330 return xerrors.Errorf("Value in field \"subject\" was too long")
2331 }
2332
2333 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
2334 return err
2335 }
2336 if _, err := cw.WriteString(string("subject")); err != nil {
2337 return err
2338 }
2339
2340 if len(t.Subject) > 1000000 {
2341 return xerrors.Errorf("Value in field t.Subject was too long")
2342 }
2343
2344 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
2345 return err
2346 }
2347 if _, err := cw.WriteString(string(t.Subject)); err != nil {
2348 return err
2349 }
2350
2351 // t.CreatedAt (string) (string)
2352 if len("createdAt") > 1000000 {
2353 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2354 }
2355
2356 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2357 return err
2358 }
2359 if _, err := cw.WriteString(string("createdAt")); err != nil {
2360 return err
2361 }
2362
2363 if len(t.CreatedAt) > 1000000 {
2364 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2365 }
2366
2367 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2368 return err
2369 }
2370 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2371 return err
2372 }
2373 return nil
2374}
2375
2376func (t *KnotMember) UnmarshalCBOR(r io.Reader) (err error) {
2377 *t = KnotMember{}
2378
2379 cr := cbg.NewCborReader(r)
2380
2381 maj, extra, err := cr.ReadHeader()
2382 if err != nil {
2383 return err
2384 }
2385 defer func() {
2386 if err == io.EOF {
2387 err = io.ErrUnexpectedEOF
2388 }
2389 }()
2390
2391 if maj != cbg.MajMap {
2392 return fmt.Errorf("cbor input should be of type map")
2393 }
2394
2395 if extra > cbg.MaxLength {
2396 return fmt.Errorf("KnotMember: map struct too large (%d)", extra)
2397 }
2398
2399 n := extra
2400
2401 nameBuf := make([]byte, 9)
2402 for i := uint64(0); i < n; i++ {
2403 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2404 if err != nil {
2405 return err
2406 }
2407
2408 if !ok {
2409 // Field doesn't exist on this type, so ignore it
2410 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2411 return err
2412 }
2413 continue
2414 }
2415
2416 switch string(nameBuf[:nameLen]) {
2417 // t.LexiconTypeID (string) (string)
2418 case "$type":
2419
2420 {
2421 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2422 if err != nil {
2423 return err
2424 }
2425
2426 t.LexiconTypeID = string(sval)
2427 }
2428 // t.Domain (string) (string)
2429 case "domain":
2430
2431 {
2432 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2433 if err != nil {
2434 return err
2435 }
2436
2437 t.Domain = string(sval)
2438 }
2439 // t.Subject (string) (string)
2440 case "subject":
2441
2442 {
2443 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2444 if err != nil {
2445 return err
2446 }
2447
2448 t.Subject = string(sval)
2449 }
2450 // t.CreatedAt (string) (string)
2451 case "createdAt":
2452
2453 {
2454 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2455 if err != nil {
2456 return err
2457 }
2458
2459 t.CreatedAt = string(sval)
2460 }
2461
2462 default:
2463 // Field doesn't exist on this type, so ignore it
2464 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2465 return err
2466 }
2467 }
2468 }
2469
2470 return nil
2471}
2472func (t *LabelDefinition) MarshalCBOR(w io.Writer) error {
2473 if t == nil {
2474 _, err := w.Write(cbg.CborNull)
2475 return err
2476 }
2477
2478 cw := cbg.NewCborWriter(w)
2479 fieldCount := 7
2480
2481 if t.Color == nil {
2482 fieldCount--
2483 }
2484
2485 if t.Multiple == nil {
2486 fieldCount--
2487 }
2488
2489 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2490 return err
2491 }
2492
2493 // t.Name (string) (string)
2494 if len("name") > 1000000 {
2495 return xerrors.Errorf("Value in field \"name\" was too long")
2496 }
2497
2498 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
2499 return err
2500 }
2501 if _, err := cw.WriteString(string("name")); err != nil {
2502 return err
2503 }
2504
2505 if len(t.Name) > 1000000 {
2506 return xerrors.Errorf("Value in field t.Name was too long")
2507 }
2508
2509 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
2510 return err
2511 }
2512 if _, err := cw.WriteString(string(t.Name)); err != nil {
2513 return err
2514 }
2515
2516 // t.LexiconTypeID (string) (string)
2517 if len("$type") > 1000000 {
2518 return xerrors.Errorf("Value in field \"$type\" was too long")
2519 }
2520
2521 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2522 return err
2523 }
2524 if _, err := cw.WriteString(string("$type")); err != nil {
2525 return err
2526 }
2527
2528 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.definition"))); err != nil {
2529 return err
2530 }
2531 if _, err := cw.WriteString(string("sh.tangled.label.definition")); err != nil {
2532 return err
2533 }
2534
2535 // t.Color (string) (string)
2536 if t.Color != nil {
2537
2538 if len("color") > 1000000 {
2539 return xerrors.Errorf("Value in field \"color\" was too long")
2540 }
2541
2542 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("color"))); err != nil {
2543 return err
2544 }
2545 if _, err := cw.WriteString(string("color")); err != nil {
2546 return err
2547 }
2548
2549 if t.Color == nil {
2550 if _, err := cw.Write(cbg.CborNull); err != nil {
2551 return err
2552 }
2553 } else {
2554 if len(*t.Color) > 1000000 {
2555 return xerrors.Errorf("Value in field t.Color was too long")
2556 }
2557
2558 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Color))); err != nil {
2559 return err
2560 }
2561 if _, err := cw.WriteString(string(*t.Color)); err != nil {
2562 return err
2563 }
2564 }
2565 }
2566
2567 // t.Scope (string) (string)
2568 if len("scope") > 1000000 {
2569 return xerrors.Errorf("Value in field \"scope\" was too long")
2570 }
2571
2572 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("scope"))); err != nil {
2573 return err
2574 }
2575 if _, err := cw.WriteString(string("scope")); err != nil {
2576 return err
2577 }
2578
2579 if len(t.Scope) > 1000000 {
2580 return xerrors.Errorf("Value in field t.Scope was too long")
2581 }
2582
2583 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Scope))); err != nil {
2584 return err
2585 }
2586 if _, err := cw.WriteString(string(t.Scope)); err != nil {
2587 return err
2588 }
2589
2590 // t.Multiple (bool) (bool)
2591 if t.Multiple != nil {
2592
2593 if len("multiple") > 1000000 {
2594 return xerrors.Errorf("Value in field \"multiple\" was too long")
2595 }
2596
2597 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("multiple"))); err != nil {
2598 return err
2599 }
2600 if _, err := cw.WriteString(string("multiple")); err != nil {
2601 return err
2602 }
2603
2604 if t.Multiple == nil {
2605 if _, err := cw.Write(cbg.CborNull); err != nil {
2606 return err
2607 }
2608 } else {
2609 if err := cbg.WriteBool(w, *t.Multiple); err != nil {
2610 return err
2611 }
2612 }
2613 }
2614
2615 // t.CreatedAt (string) (string)
2616 if len("createdAt") > 1000000 {
2617 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2618 }
2619
2620 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2621 return err
2622 }
2623 if _, err := cw.WriteString(string("createdAt")); err != nil {
2624 return err
2625 }
2626
2627 if len(t.CreatedAt) > 1000000 {
2628 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2629 }
2630
2631 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2632 return err
2633 }
2634 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2635 return err
2636 }
2637
2638 // t.ValueType (tangled.LabelDefinition_ValueType) (struct)
2639 if len("valueType") > 1000000 {
2640 return xerrors.Errorf("Value in field \"valueType\" was too long")
2641 }
2642
2643 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("valueType"))); err != nil {
2644 return err
2645 }
2646 if _, err := cw.WriteString(string("valueType")); err != nil {
2647 return err
2648 }
2649
2650 if err := t.ValueType.MarshalCBOR(cw); err != nil {
2651 return err
2652 }
2653 return nil
2654}
2655
2656func (t *LabelDefinition) UnmarshalCBOR(r io.Reader) (err error) {
2657 *t = LabelDefinition{}
2658
2659 cr := cbg.NewCborReader(r)
2660
2661 maj, extra, err := cr.ReadHeader()
2662 if err != nil {
2663 return err
2664 }
2665 defer func() {
2666 if err == io.EOF {
2667 err = io.ErrUnexpectedEOF
2668 }
2669 }()
2670
2671 if maj != cbg.MajMap {
2672 return fmt.Errorf("cbor input should be of type map")
2673 }
2674
2675 if extra > cbg.MaxLength {
2676 return fmt.Errorf("LabelDefinition: map struct too large (%d)", extra)
2677 }
2678
2679 n := extra
2680
2681 nameBuf := make([]byte, 9)
2682 for i := uint64(0); i < n; i++ {
2683 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2684 if err != nil {
2685 return err
2686 }
2687
2688 if !ok {
2689 // Field doesn't exist on this type, so ignore it
2690 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2691 return err
2692 }
2693 continue
2694 }
2695
2696 switch string(nameBuf[:nameLen]) {
2697 // t.Name (string) (string)
2698 case "name":
2699
2700 {
2701 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2702 if err != nil {
2703 return err
2704 }
2705
2706 t.Name = string(sval)
2707 }
2708 // t.LexiconTypeID (string) (string)
2709 case "$type":
2710
2711 {
2712 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2713 if err != nil {
2714 return err
2715 }
2716
2717 t.LexiconTypeID = string(sval)
2718 }
2719 // t.Color (string) (string)
2720 case "color":
2721
2722 {
2723 b, err := cr.ReadByte()
2724 if err != nil {
2725 return err
2726 }
2727 if b != cbg.CborNull[0] {
2728 if err := cr.UnreadByte(); err != nil {
2729 return err
2730 }
2731
2732 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2733 if err != nil {
2734 return err
2735 }
2736
2737 t.Color = (*string)(&sval)
2738 }
2739 }
2740 // t.Scope (string) (string)
2741 case "scope":
2742
2743 {
2744 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2745 if err != nil {
2746 return err
2747 }
2748
2749 t.Scope = string(sval)
2750 }
2751 // t.Multiple (bool) (bool)
2752 case "multiple":
2753
2754 {
2755 b, err := cr.ReadByte()
2756 if err != nil {
2757 return err
2758 }
2759 if b != cbg.CborNull[0] {
2760 if err := cr.UnreadByte(); err != nil {
2761 return err
2762 }
2763
2764 maj, extra, err = cr.ReadHeader()
2765 if err != nil {
2766 return err
2767 }
2768 if maj != cbg.MajOther {
2769 return fmt.Errorf("booleans must be major type 7")
2770 }
2771
2772 var val bool
2773 switch extra {
2774 case 20:
2775 val = false
2776 case 21:
2777 val = true
2778 default:
2779 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
2780 }
2781 t.Multiple = &val
2782 }
2783 }
2784 // t.CreatedAt (string) (string)
2785 case "createdAt":
2786
2787 {
2788 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2789 if err != nil {
2790 return err
2791 }
2792
2793 t.CreatedAt = string(sval)
2794 }
2795 // t.ValueType (tangled.LabelDefinition_ValueType) (struct)
2796 case "valueType":
2797
2798 {
2799
2800 b, err := cr.ReadByte()
2801 if err != nil {
2802 return err
2803 }
2804 if b != cbg.CborNull[0] {
2805 if err := cr.UnreadByte(); err != nil {
2806 return err
2807 }
2808 t.ValueType = new(LabelDefinition_ValueType)
2809 if err := t.ValueType.UnmarshalCBOR(cr); err != nil {
2810 return xerrors.Errorf("unmarshaling t.ValueType pointer: %w", err)
2811 }
2812 }
2813
2814 }
2815
2816 default:
2817 // Field doesn't exist on this type, so ignore it
2818 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2819 return err
2820 }
2821 }
2822 }
2823
2824 return nil
2825}
2826func (t *LabelDefinition_ValueType) MarshalCBOR(w io.Writer) error {
2827 if t == nil {
2828 _, err := w.Write(cbg.CborNull)
2829 return err
2830 }
2831
2832 cw := cbg.NewCborWriter(w)
2833 fieldCount := 4
2834
2835 if t.Enum == nil {
2836 fieldCount--
2837 }
2838
2839 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2840 return err
2841 }
2842
2843 // t.Enum ([]string) (slice)
2844 if t.Enum != nil {
2845
2846 if len("enum") > 1000000 {
2847 return xerrors.Errorf("Value in field \"enum\" was too long")
2848 }
2849
2850 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("enum"))); err != nil {
2851 return err
2852 }
2853 if _, err := cw.WriteString(string("enum")); err != nil {
2854 return err
2855 }
2856
2857 if len(t.Enum) > 8192 {
2858 return xerrors.Errorf("Slice value in field t.Enum was too long")
2859 }
2860
2861 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Enum))); err != nil {
2862 return err
2863 }
2864 for _, v := range t.Enum {
2865 if len(v) > 1000000 {
2866 return xerrors.Errorf("Value in field v was too long")
2867 }
2868
2869 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
2870 return err
2871 }
2872 if _, err := cw.WriteString(string(v)); err != nil {
2873 return err
2874 }
2875
2876 }
2877 }
2878
2879 // t.Type (string) (string)
2880 if len("type") > 1000000 {
2881 return xerrors.Errorf("Value in field \"type\" was too long")
2882 }
2883
2884 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("type"))); err != nil {
2885 return err
2886 }
2887 if _, err := cw.WriteString(string("type")); err != nil {
2888 return err
2889 }
2890
2891 if len(t.Type) > 1000000 {
2892 return xerrors.Errorf("Value in field t.Type was too long")
2893 }
2894
2895 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Type))); err != nil {
2896 return err
2897 }
2898 if _, err := cw.WriteString(string(t.Type)); err != nil {
2899 return err
2900 }
2901
2902 // t.LexiconTypeID (string) (string)
2903 if len("$type") > 1000000 {
2904 return xerrors.Errorf("Value in field \"$type\" was too long")
2905 }
2906
2907 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2908 return err
2909 }
2910 if _, err := cw.WriteString(string("$type")); err != nil {
2911 return err
2912 }
2913
2914 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.definition"))); err != nil {
2915 return err
2916 }
2917 if _, err := cw.WriteString(string("sh.tangled.label.definition")); err != nil {
2918 return err
2919 }
2920
2921 // t.Format (string) (string)
2922 if len("format") > 1000000 {
2923 return xerrors.Errorf("Value in field \"format\" was too long")
2924 }
2925
2926 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("format"))); err != nil {
2927 return err
2928 }
2929 if _, err := cw.WriteString(string("format")); err != nil {
2930 return err
2931 }
2932
2933 if len(t.Format) > 1000000 {
2934 return xerrors.Errorf("Value in field t.Format was too long")
2935 }
2936
2937 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Format))); err != nil {
2938 return err
2939 }
2940 if _, err := cw.WriteString(string(t.Format)); err != nil {
2941 return err
2942 }
2943 return nil
2944}
2945
2946func (t *LabelDefinition_ValueType) UnmarshalCBOR(r io.Reader) (err error) {
2947 *t = LabelDefinition_ValueType{}
2948
2949 cr := cbg.NewCborReader(r)
2950
2951 maj, extra, err := cr.ReadHeader()
2952 if err != nil {
2953 return err
2954 }
2955 defer func() {
2956 if err == io.EOF {
2957 err = io.ErrUnexpectedEOF
2958 }
2959 }()
2960
2961 if maj != cbg.MajMap {
2962 return fmt.Errorf("cbor input should be of type map")
2963 }
2964
2965 if extra > cbg.MaxLength {
2966 return fmt.Errorf("LabelDefinition_ValueType: map struct too large (%d)", extra)
2967 }
2968
2969 n := extra
2970
2971 nameBuf := make([]byte, 6)
2972 for i := uint64(0); i < n; i++ {
2973 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2974 if err != nil {
2975 return err
2976 }
2977
2978 if !ok {
2979 // Field doesn't exist on this type, so ignore it
2980 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2981 return err
2982 }
2983 continue
2984 }
2985
2986 switch string(nameBuf[:nameLen]) {
2987 // t.Enum ([]string) (slice)
2988 case "enum":
2989
2990 maj, extra, err = cr.ReadHeader()
2991 if err != nil {
2992 return err
2993 }
2994
2995 if extra > 8192 {
2996 return fmt.Errorf("t.Enum: array too large (%d)", extra)
2997 }
2998
2999 if maj != cbg.MajArray {
3000 return fmt.Errorf("expected cbor array")
3001 }
3002
3003 if extra > 0 {
3004 t.Enum = make([]string, extra)
3005 }
3006
3007 for i := 0; i < int(extra); i++ {
3008 {
3009 var maj byte
3010 var extra uint64
3011 var err error
3012 _ = maj
3013 _ = extra
3014 _ = err
3015
3016 {
3017 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3018 if err != nil {
3019 return err
3020 }
3021
3022 t.Enum[i] = string(sval)
3023 }
3024
3025 }
3026 }
3027 // t.Type (string) (string)
3028 case "type":
3029
3030 {
3031 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3032 if err != nil {
3033 return err
3034 }
3035
3036 t.Type = string(sval)
3037 }
3038 // t.LexiconTypeID (string) (string)
3039 case "$type":
3040
3041 {
3042 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3043 if err != nil {
3044 return err
3045 }
3046
3047 t.LexiconTypeID = string(sval)
3048 }
3049 // t.Format (string) (string)
3050 case "format":
3051
3052 {
3053 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3054 if err != nil {
3055 return err
3056 }
3057
3058 t.Format = string(sval)
3059 }
3060
3061 default:
3062 // Field doesn't exist on this type, so ignore it
3063 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3064 return err
3065 }
3066 }
3067 }
3068
3069 return nil
3070}
3071func (t *LabelOp) MarshalCBOR(w io.Writer) error {
3072 if t == nil {
3073 _, err := w.Write(cbg.CborNull)
3074 return err
3075 }
3076
3077 cw := cbg.NewCborWriter(w)
3078
3079 if _, err := cw.Write([]byte{165}); err != nil {
3080 return err
3081 }
3082
3083 // t.Add ([]*tangled.LabelOp_Operand) (slice)
3084 if len("add") > 1000000 {
3085 return xerrors.Errorf("Value in field \"add\" was too long")
3086 }
3087
3088 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("add"))); err != nil {
3089 return err
3090 }
3091 if _, err := cw.WriteString(string("add")); err != nil {
3092 return err
3093 }
3094
3095 if len(t.Add) > 8192 {
3096 return xerrors.Errorf("Slice value in field t.Add was too long")
3097 }
3098
3099 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Add))); err != nil {
3100 return err
3101 }
3102 for _, v := range t.Add {
3103 if err := v.MarshalCBOR(cw); err != nil {
3104 return err
3105 }
3106
3107 }
3108
3109 // t.LexiconTypeID (string) (string)
3110 if len("$type") > 1000000 {
3111 return xerrors.Errorf("Value in field \"$type\" was too long")
3112 }
3113
3114 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3115 return err
3116 }
3117 if _, err := cw.WriteString(string("$type")); err != nil {
3118 return err
3119 }
3120
3121 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.op"))); err != nil {
3122 return err
3123 }
3124 if _, err := cw.WriteString(string("sh.tangled.label.op")); err != nil {
3125 return err
3126 }
3127
3128 // t.Delete ([]*tangled.LabelOp_Operand) (slice)
3129 if len("delete") > 1000000 {
3130 return xerrors.Errorf("Value in field \"delete\" was too long")
3131 }
3132
3133 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("delete"))); err != nil {
3134 return err
3135 }
3136 if _, err := cw.WriteString(string("delete")); err != nil {
3137 return err
3138 }
3139
3140 if len(t.Delete) > 8192 {
3141 return xerrors.Errorf("Slice value in field t.Delete was too long")
3142 }
3143
3144 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Delete))); err != nil {
3145 return err
3146 }
3147 for _, v := range t.Delete {
3148 if err := v.MarshalCBOR(cw); err != nil {
3149 return err
3150 }
3151
3152 }
3153
3154 // t.Subject (string) (string)
3155 if len("subject") > 1000000 {
3156 return xerrors.Errorf("Value in field \"subject\" was too long")
3157 }
3158
3159 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
3160 return err
3161 }
3162 if _, err := cw.WriteString(string("subject")); err != nil {
3163 return err
3164 }
3165
3166 if len(t.Subject) > 1000000 {
3167 return xerrors.Errorf("Value in field t.Subject was too long")
3168 }
3169
3170 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
3171 return err
3172 }
3173 if _, err := cw.WriteString(string(t.Subject)); err != nil {
3174 return err
3175 }
3176
3177 // t.PerformedAt (string) (string)
3178 if len("performedAt") > 1000000 {
3179 return xerrors.Errorf("Value in field \"performedAt\" was too long")
3180 }
3181
3182 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("performedAt"))); err != nil {
3183 return err
3184 }
3185 if _, err := cw.WriteString(string("performedAt")); err != nil {
3186 return err
3187 }
3188
3189 if len(t.PerformedAt) > 1000000 {
3190 return xerrors.Errorf("Value in field t.PerformedAt was too long")
3191 }
3192
3193 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.PerformedAt))); err != nil {
3194 return err
3195 }
3196 if _, err := cw.WriteString(string(t.PerformedAt)); err != nil {
3197 return err
3198 }
3199 return nil
3200}
3201
3202func (t *LabelOp) UnmarshalCBOR(r io.Reader) (err error) {
3203 *t = LabelOp{}
3204
3205 cr := cbg.NewCborReader(r)
3206
3207 maj, extra, err := cr.ReadHeader()
3208 if err != nil {
3209 return err
3210 }
3211 defer func() {
3212 if err == io.EOF {
3213 err = io.ErrUnexpectedEOF
3214 }
3215 }()
3216
3217 if maj != cbg.MajMap {
3218 return fmt.Errorf("cbor input should be of type map")
3219 }
3220
3221 if extra > cbg.MaxLength {
3222 return fmt.Errorf("LabelOp: map struct too large (%d)", extra)
3223 }
3224
3225 n := extra
3226
3227 nameBuf := make([]byte, 11)
3228 for i := uint64(0); i < n; i++ {
3229 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3230 if err != nil {
3231 return err
3232 }
3233
3234 if !ok {
3235 // Field doesn't exist on this type, so ignore it
3236 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3237 return err
3238 }
3239 continue
3240 }
3241
3242 switch string(nameBuf[:nameLen]) {
3243 // t.Add ([]*tangled.LabelOp_Operand) (slice)
3244 case "add":
3245
3246 maj, extra, err = cr.ReadHeader()
3247 if err != nil {
3248 return err
3249 }
3250
3251 if extra > 8192 {
3252 return fmt.Errorf("t.Add: array too large (%d)", extra)
3253 }
3254
3255 if maj != cbg.MajArray {
3256 return fmt.Errorf("expected cbor array")
3257 }
3258
3259 if extra > 0 {
3260 t.Add = make([]*LabelOp_Operand, extra)
3261 }
3262
3263 for i := 0; i < int(extra); i++ {
3264 {
3265 var maj byte
3266 var extra uint64
3267 var err error
3268 _ = maj
3269 _ = extra
3270 _ = err
3271
3272 {
3273
3274 b, err := cr.ReadByte()
3275 if err != nil {
3276 return err
3277 }
3278 if b != cbg.CborNull[0] {
3279 if err := cr.UnreadByte(); err != nil {
3280 return err
3281 }
3282 t.Add[i] = new(LabelOp_Operand)
3283 if err := t.Add[i].UnmarshalCBOR(cr); err != nil {
3284 return xerrors.Errorf("unmarshaling t.Add[i] pointer: %w", err)
3285 }
3286 }
3287
3288 }
3289
3290 }
3291 }
3292 // t.LexiconTypeID (string) (string)
3293 case "$type":
3294
3295 {
3296 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3297 if err != nil {
3298 return err
3299 }
3300
3301 t.LexiconTypeID = string(sval)
3302 }
3303 // t.Delete ([]*tangled.LabelOp_Operand) (slice)
3304 case "delete":
3305
3306 maj, extra, err = cr.ReadHeader()
3307 if err != nil {
3308 return err
3309 }
3310
3311 if extra > 8192 {
3312 return fmt.Errorf("t.Delete: array too large (%d)", extra)
3313 }
3314
3315 if maj != cbg.MajArray {
3316 return fmt.Errorf("expected cbor array")
3317 }
3318
3319 if extra > 0 {
3320 t.Delete = make([]*LabelOp_Operand, extra)
3321 }
3322
3323 for i := 0; i < int(extra); i++ {
3324 {
3325 var maj byte
3326 var extra uint64
3327 var err error
3328 _ = maj
3329 _ = extra
3330 _ = err
3331
3332 {
3333
3334 b, err := cr.ReadByte()
3335 if err != nil {
3336 return err
3337 }
3338 if b != cbg.CborNull[0] {
3339 if err := cr.UnreadByte(); err != nil {
3340 return err
3341 }
3342 t.Delete[i] = new(LabelOp_Operand)
3343 if err := t.Delete[i].UnmarshalCBOR(cr); err != nil {
3344 return xerrors.Errorf("unmarshaling t.Delete[i] pointer: %w", err)
3345 }
3346 }
3347
3348 }
3349
3350 }
3351 }
3352 // t.Subject (string) (string)
3353 case "subject":
3354
3355 {
3356 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3357 if err != nil {
3358 return err
3359 }
3360
3361 t.Subject = string(sval)
3362 }
3363 // t.PerformedAt (string) (string)
3364 case "performedAt":
3365
3366 {
3367 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3368 if err != nil {
3369 return err
3370 }
3371
3372 t.PerformedAt = string(sval)
3373 }
3374
3375 default:
3376 // Field doesn't exist on this type, so ignore it
3377 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3378 return err
3379 }
3380 }
3381 }
3382
3383 return nil
3384}
3385func (t *LabelOp_Operand) MarshalCBOR(w io.Writer) error {
3386 if t == nil {
3387 _, err := w.Write(cbg.CborNull)
3388 return err
3389 }
3390
3391 cw := cbg.NewCborWriter(w)
3392
3393 if _, err := cw.Write([]byte{162}); err != nil {
3394 return err
3395 }
3396
3397 // t.Key (string) (string)
3398 if len("key") > 1000000 {
3399 return xerrors.Errorf("Value in field \"key\" was too long")
3400 }
3401
3402 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
3403 return err
3404 }
3405 if _, err := cw.WriteString(string("key")); err != nil {
3406 return err
3407 }
3408
3409 if len(t.Key) > 1000000 {
3410 return xerrors.Errorf("Value in field t.Key was too long")
3411 }
3412
3413 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
3414 return err
3415 }
3416 if _, err := cw.WriteString(string(t.Key)); err != nil {
3417 return err
3418 }
3419
3420 // t.Value (string) (string)
3421 if len("value") > 1000000 {
3422 return xerrors.Errorf("Value in field \"value\" was too long")
3423 }
3424
3425 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
3426 return err
3427 }
3428 if _, err := cw.WriteString(string("value")); err != nil {
3429 return err
3430 }
3431
3432 if len(t.Value) > 1000000 {
3433 return xerrors.Errorf("Value in field t.Value was too long")
3434 }
3435
3436 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
3437 return err
3438 }
3439 if _, err := cw.WriteString(string(t.Value)); err != nil {
3440 return err
3441 }
3442 return nil
3443}
3444
3445func (t *LabelOp_Operand) UnmarshalCBOR(r io.Reader) (err error) {
3446 *t = LabelOp_Operand{}
3447
3448 cr := cbg.NewCborReader(r)
3449
3450 maj, extra, err := cr.ReadHeader()
3451 if err != nil {
3452 return err
3453 }
3454 defer func() {
3455 if err == io.EOF {
3456 err = io.ErrUnexpectedEOF
3457 }
3458 }()
3459
3460 if maj != cbg.MajMap {
3461 return fmt.Errorf("cbor input should be of type map")
3462 }
3463
3464 if extra > cbg.MaxLength {
3465 return fmt.Errorf("LabelOp_Operand: map struct too large (%d)", extra)
3466 }
3467
3468 n := extra
3469
3470 nameBuf := make([]byte, 5)
3471 for i := uint64(0); i < n; i++ {
3472 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3473 if err != nil {
3474 return err
3475 }
3476
3477 if !ok {
3478 // Field doesn't exist on this type, so ignore it
3479 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3480 return err
3481 }
3482 continue
3483 }
3484
3485 switch string(nameBuf[:nameLen]) {
3486 // t.Key (string) (string)
3487 case "key":
3488
3489 {
3490 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3491 if err != nil {
3492 return err
3493 }
3494
3495 t.Key = string(sval)
3496 }
3497 // t.Value (string) (string)
3498 case "value":
3499
3500 {
3501 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3502 if err != nil {
3503 return err
3504 }
3505
3506 t.Value = string(sval)
3507 }
3508
3509 default:
3510 // Field doesn't exist on this type, so ignore it
3511 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3512 return err
3513 }
3514 }
3515 }
3516
3517 return nil
3518}
3519func (t *Pipeline) MarshalCBOR(w io.Writer) error {
3520 if t == nil {
3521 _, err := w.Write(cbg.CborNull)
3522 return err
3523 }
3524
3525 cw := cbg.NewCborWriter(w)
3526
3527 if _, err := cw.Write([]byte{163}); err != nil {
3528 return err
3529 }
3530
3531 // t.LexiconTypeID (string) (string)
3532 if len("$type") > 1000000 {
3533 return xerrors.Errorf("Value in field \"$type\" was too long")
3534 }
3535
3536 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3537 return err
3538 }
3539 if _, err := cw.WriteString(string("$type")); err != nil {
3540 return err
3541 }
3542
3543 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil {
3544 return err
3545 }
3546 if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil {
3547 return err
3548 }
3549
3550 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
3551 if len("workflows") > 1000000 {
3552 return xerrors.Errorf("Value in field \"workflows\" was too long")
3553 }
3554
3555 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil {
3556 return err
3557 }
3558 if _, err := cw.WriteString(string("workflows")); err != nil {
3559 return err
3560 }
3561
3562 if len(t.Workflows) > 8192 {
3563 return xerrors.Errorf("Slice value in field t.Workflows was too long")
3564 }
3565
3566 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil {
3567 return err
3568 }
3569 for _, v := range t.Workflows {
3570 if err := v.MarshalCBOR(cw); err != nil {
3571 return err
3572 }
3573
3574 }
3575
3576 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
3577 if len("triggerMetadata") > 1000000 {
3578 return xerrors.Errorf("Value in field \"triggerMetadata\" was too long")
3579 }
3580
3581 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil {
3582 return err
3583 }
3584 if _, err := cw.WriteString(string("triggerMetadata")); err != nil {
3585 return err
3586 }
3587
3588 if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil {
3589 return err
3590 }
3591 return nil
3592}
3593
3594func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) {
3595 *t = Pipeline{}
3596
3597 cr := cbg.NewCborReader(r)
3598
3599 maj, extra, err := cr.ReadHeader()
3600 if err != nil {
3601 return err
3602 }
3603 defer func() {
3604 if err == io.EOF {
3605 err = io.ErrUnexpectedEOF
3606 }
3607 }()
3608
3609 if maj != cbg.MajMap {
3610 return fmt.Errorf("cbor input should be of type map")
3611 }
3612
3613 if extra > cbg.MaxLength {
3614 return fmt.Errorf("Pipeline: map struct too large (%d)", extra)
3615 }
3616
3617 n := extra
3618
3619 nameBuf := make([]byte, 15)
3620 for i := uint64(0); i < n; i++ {
3621 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3622 if err != nil {
3623 return err
3624 }
3625
3626 if !ok {
3627 // Field doesn't exist on this type, so ignore it
3628 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3629 return err
3630 }
3631 continue
3632 }
3633
3634 switch string(nameBuf[:nameLen]) {
3635 // t.LexiconTypeID (string) (string)
3636 case "$type":
3637
3638 {
3639 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3640 if err != nil {
3641 return err
3642 }
3643
3644 t.LexiconTypeID = string(sval)
3645 }
3646 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
3647 case "workflows":
3648
3649 maj, extra, err = cr.ReadHeader()
3650 if err != nil {
3651 return err
3652 }
3653
3654 if extra > 8192 {
3655 return fmt.Errorf("t.Workflows: array too large (%d)", extra)
3656 }
3657
3658 if maj != cbg.MajArray {
3659 return fmt.Errorf("expected cbor array")
3660 }
3661
3662 if extra > 0 {
3663 t.Workflows = make([]*Pipeline_Workflow, extra)
3664 }
3665
3666 for i := 0; i < int(extra); i++ {
3667 {
3668 var maj byte
3669 var extra uint64
3670 var err error
3671 _ = maj
3672 _ = extra
3673 _ = err
3674
3675 {
3676
3677 b, err := cr.ReadByte()
3678 if err != nil {
3679 return err
3680 }
3681 if b != cbg.CborNull[0] {
3682 if err := cr.UnreadByte(); err != nil {
3683 return err
3684 }
3685 t.Workflows[i] = new(Pipeline_Workflow)
3686 if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil {
3687 return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err)
3688 }
3689 }
3690
3691 }
3692
3693 }
3694 }
3695 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
3696 case "triggerMetadata":
3697
3698 {
3699
3700 b, err := cr.ReadByte()
3701 if err != nil {
3702 return err
3703 }
3704 if b != cbg.CborNull[0] {
3705 if err := cr.UnreadByte(); err != nil {
3706 return err
3707 }
3708 t.TriggerMetadata = new(Pipeline_TriggerMetadata)
3709 if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil {
3710 return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err)
3711 }
3712 }
3713
3714 }
3715
3716 default:
3717 // Field doesn't exist on this type, so ignore it
3718 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3719 return err
3720 }
3721 }
3722 }
3723
3724 return nil
3725}
3726func (t *Pipeline_CloneOpts) MarshalCBOR(w io.Writer) error {
3727 if t == nil {
3728 _, err := w.Write(cbg.CborNull)
3729 return err
3730 }
3731
3732 cw := cbg.NewCborWriter(w)
3733
3734 if _, err := cw.Write([]byte{163}); err != nil {
3735 return err
3736 }
3737
3738 // t.Skip (bool) (bool)
3739 if len("skip") > 1000000 {
3740 return xerrors.Errorf("Value in field \"skip\" was too long")
3741 }
3742
3743 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("skip"))); err != nil {
3744 return err
3745 }
3746 if _, err := cw.WriteString(string("skip")); err != nil {
3747 return err
3748 }
3749
3750 if err := cbg.WriteBool(w, t.Skip); err != nil {
3751 return err
3752 }
3753
3754 // t.Depth (int64) (int64)
3755 if len("depth") > 1000000 {
3756 return xerrors.Errorf("Value in field \"depth\" was too long")
3757 }
3758
3759 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("depth"))); err != nil {
3760 return err
3761 }
3762 if _, err := cw.WriteString(string("depth")); err != nil {
3763 return err
3764 }
3765
3766 if t.Depth >= 0 {
3767 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Depth)); err != nil {
3768 return err
3769 }
3770 } else {
3771 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Depth-1)); err != nil {
3772 return err
3773 }
3774 }
3775
3776 // t.Submodules (bool) (bool)
3777 if len("submodules") > 1000000 {
3778 return xerrors.Errorf("Value in field \"submodules\" was too long")
3779 }
3780
3781 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("submodules"))); err != nil {
3782 return err
3783 }
3784 if _, err := cw.WriteString(string("submodules")); err != nil {
3785 return err
3786 }
3787
3788 if err := cbg.WriteBool(w, t.Submodules); err != nil {
3789 return err
3790 }
3791 return nil
3792}
3793
3794func (t *Pipeline_CloneOpts) UnmarshalCBOR(r io.Reader) (err error) {
3795 *t = Pipeline_CloneOpts{}
3796
3797 cr := cbg.NewCborReader(r)
3798
3799 maj, extra, err := cr.ReadHeader()
3800 if err != nil {
3801 return err
3802 }
3803 defer func() {
3804 if err == io.EOF {
3805 err = io.ErrUnexpectedEOF
3806 }
3807 }()
3808
3809 if maj != cbg.MajMap {
3810 return fmt.Errorf("cbor input should be of type map")
3811 }
3812
3813 if extra > cbg.MaxLength {
3814 return fmt.Errorf("Pipeline_CloneOpts: map struct too large (%d)", extra)
3815 }
3816
3817 n := extra
3818
3819 nameBuf := make([]byte, 10)
3820 for i := uint64(0); i < n; i++ {
3821 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3822 if err != nil {
3823 return err
3824 }
3825
3826 if !ok {
3827 // Field doesn't exist on this type, so ignore it
3828 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3829 return err
3830 }
3831 continue
3832 }
3833
3834 switch string(nameBuf[:nameLen]) {
3835 // t.Skip (bool) (bool)
3836 case "skip":
3837
3838 maj, extra, err = cr.ReadHeader()
3839 if err != nil {
3840 return err
3841 }
3842 if maj != cbg.MajOther {
3843 return fmt.Errorf("booleans must be major type 7")
3844 }
3845 switch extra {
3846 case 20:
3847 t.Skip = false
3848 case 21:
3849 t.Skip = true
3850 default:
3851 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
3852 }
3853 // t.Depth (int64) (int64)
3854 case "depth":
3855 {
3856 maj, extra, err := cr.ReadHeader()
3857 if err != nil {
3858 return err
3859 }
3860 var extraI int64
3861 switch maj {
3862 case cbg.MajUnsignedInt:
3863 extraI = int64(extra)
3864 if extraI < 0 {
3865 return fmt.Errorf("int64 positive overflow")
3866 }
3867 case cbg.MajNegativeInt:
3868 extraI = int64(extra)
3869 if extraI < 0 {
3870 return fmt.Errorf("int64 negative overflow")
3871 }
3872 extraI = -1 - extraI
3873 default:
3874 return fmt.Errorf("wrong type for int64 field: %d", maj)
3875 }
3876
3877 t.Depth = int64(extraI)
3878 }
3879 // t.Submodules (bool) (bool)
3880 case "submodules":
3881
3882 maj, extra, err = cr.ReadHeader()
3883 if err != nil {
3884 return err
3885 }
3886 if maj != cbg.MajOther {
3887 return fmt.Errorf("booleans must be major type 7")
3888 }
3889 switch extra {
3890 case 20:
3891 t.Submodules = false
3892 case 21:
3893 t.Submodules = true
3894 default:
3895 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
3896 }
3897
3898 default:
3899 // Field doesn't exist on this type, so ignore it
3900 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3901 return err
3902 }
3903 }
3904 }
3905
3906 return nil
3907}
3908func (t *Pipeline_ManualTriggerData) MarshalCBOR(w io.Writer) error {
3909 if t == nil {
3910 _, err := w.Write(cbg.CborNull)
3911 return err
3912 }
3913
3914 cw := cbg.NewCborWriter(w)
3915 fieldCount := 1
3916
3917 if t.Inputs == nil {
3918 fieldCount--
3919 }
3920
3921 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3922 return err
3923 }
3924
3925 // t.Inputs ([]*tangled.Pipeline_Pair) (slice)
3926 if t.Inputs != nil {
3927
3928 if len("inputs") > 1000000 {
3929 return xerrors.Errorf("Value in field \"inputs\" was too long")
3930 }
3931
3932 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
3933 return err
3934 }
3935 if _, err := cw.WriteString(string("inputs")); err != nil {
3936 return err
3937 }
3938
3939 if len(t.Inputs) > 8192 {
3940 return xerrors.Errorf("Slice value in field t.Inputs was too long")
3941 }
3942
3943 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
3944 return err
3945 }
3946 for _, v := range t.Inputs {
3947 if err := v.MarshalCBOR(cw); err != nil {
3948 return err
3949 }
3950
3951 }
3952 }
3953 return nil
3954}
3955
3956func (t *Pipeline_ManualTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
3957 *t = Pipeline_ManualTriggerData{}
3958
3959 cr := cbg.NewCborReader(r)
3960
3961 maj, extra, err := cr.ReadHeader()
3962 if err != nil {
3963 return err
3964 }
3965 defer func() {
3966 if err == io.EOF {
3967 err = io.ErrUnexpectedEOF
3968 }
3969 }()
3970
3971 if maj != cbg.MajMap {
3972 return fmt.Errorf("cbor input should be of type map")
3973 }
3974
3975 if extra > cbg.MaxLength {
3976 return fmt.Errorf("Pipeline_ManualTriggerData: map struct too large (%d)", extra)
3977 }
3978
3979 n := extra
3980
3981 nameBuf := make([]byte, 6)
3982 for i := uint64(0); i < n; i++ {
3983 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3984 if err != nil {
3985 return err
3986 }
3987
3988 if !ok {
3989 // Field doesn't exist on this type, so ignore it
3990 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3991 return err
3992 }
3993 continue
3994 }
3995
3996 switch string(nameBuf[:nameLen]) {
3997 // t.Inputs ([]*tangled.Pipeline_Pair) (slice)
3998 case "inputs":
3999
4000 maj, extra, err = cr.ReadHeader()
4001 if err != nil {
4002 return err
4003 }
4004
4005 if extra > 8192 {
4006 return fmt.Errorf("t.Inputs: array too large (%d)", extra)
4007 }
4008
4009 if maj != cbg.MajArray {
4010 return fmt.Errorf("expected cbor array")
4011 }
4012
4013 if extra > 0 {
4014 t.Inputs = make([]*Pipeline_Pair, extra)
4015 }
4016
4017 for i := 0; i < int(extra); i++ {
4018 {
4019 var maj byte
4020 var extra uint64
4021 var err error
4022 _ = maj
4023 _ = extra
4024 _ = err
4025
4026 {
4027
4028 b, err := cr.ReadByte()
4029 if err != nil {
4030 return err
4031 }
4032 if b != cbg.CborNull[0] {
4033 if err := cr.UnreadByte(); err != nil {
4034 return err
4035 }
4036 t.Inputs[i] = new(Pipeline_Pair)
4037 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
4038 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
4039 }
4040 }
4041
4042 }
4043
4044 }
4045 }
4046
4047 default:
4048 // Field doesn't exist on this type, so ignore it
4049 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4050 return err
4051 }
4052 }
4053 }
4054
4055 return nil
4056}
4057func (t *Pipeline_Pair) MarshalCBOR(w io.Writer) error {
4058 if t == nil {
4059 _, err := w.Write(cbg.CborNull)
4060 return err
4061 }
4062
4063 cw := cbg.NewCborWriter(w)
4064
4065 if _, err := cw.Write([]byte{162}); err != nil {
4066 return err
4067 }
4068
4069 // t.Key (string) (string)
4070 if len("key") > 1000000 {
4071 return xerrors.Errorf("Value in field \"key\" was too long")
4072 }
4073
4074 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
4075 return err
4076 }
4077 if _, err := cw.WriteString(string("key")); err != nil {
4078 return err
4079 }
4080
4081 if len(t.Key) > 1000000 {
4082 return xerrors.Errorf("Value in field t.Key was too long")
4083 }
4084
4085 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
4086 return err
4087 }
4088 if _, err := cw.WriteString(string(t.Key)); err != nil {
4089 return err
4090 }
4091
4092 // t.Value (string) (string)
4093 if len("value") > 1000000 {
4094 return xerrors.Errorf("Value in field \"value\" was too long")
4095 }
4096
4097 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
4098 return err
4099 }
4100 if _, err := cw.WriteString(string("value")); err != nil {
4101 return err
4102 }
4103
4104 if len(t.Value) > 1000000 {
4105 return xerrors.Errorf("Value in field t.Value was too long")
4106 }
4107
4108 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
4109 return err
4110 }
4111 if _, err := cw.WriteString(string(t.Value)); err != nil {
4112 return err
4113 }
4114 return nil
4115}
4116
4117func (t *Pipeline_Pair) UnmarshalCBOR(r io.Reader) (err error) {
4118 *t = Pipeline_Pair{}
4119
4120 cr := cbg.NewCborReader(r)
4121
4122 maj, extra, err := cr.ReadHeader()
4123 if err != nil {
4124 return err
4125 }
4126 defer func() {
4127 if err == io.EOF {
4128 err = io.ErrUnexpectedEOF
4129 }
4130 }()
4131
4132 if maj != cbg.MajMap {
4133 return fmt.Errorf("cbor input should be of type map")
4134 }
4135
4136 if extra > cbg.MaxLength {
4137 return fmt.Errorf("Pipeline_Pair: map struct too large (%d)", extra)
4138 }
4139
4140 n := extra
4141
4142 nameBuf := make([]byte, 5)
4143 for i := uint64(0); i < n; i++ {
4144 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4145 if err != nil {
4146 return err
4147 }
4148
4149 if !ok {
4150 // Field doesn't exist on this type, so ignore it
4151 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4152 return err
4153 }
4154 continue
4155 }
4156
4157 switch string(nameBuf[:nameLen]) {
4158 // t.Key (string) (string)
4159 case "key":
4160
4161 {
4162 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4163 if err != nil {
4164 return err
4165 }
4166
4167 t.Key = string(sval)
4168 }
4169 // t.Value (string) (string)
4170 case "value":
4171
4172 {
4173 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4174 if err != nil {
4175 return err
4176 }
4177
4178 t.Value = string(sval)
4179 }
4180
4181 default:
4182 // Field doesn't exist on this type, so ignore it
4183 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4184 return err
4185 }
4186 }
4187 }
4188
4189 return nil
4190}
4191func (t *Pipeline_PullRequestTriggerData) MarshalCBOR(w io.Writer) error {
4192 if t == nil {
4193 _, err := w.Write(cbg.CborNull)
4194 return err
4195 }
4196
4197 cw := cbg.NewCborWriter(w)
4198
4199 if _, err := cw.Write([]byte{164}); err != nil {
4200 return err
4201 }
4202
4203 // t.Action (string) (string)
4204 if len("action") > 1000000 {
4205 return xerrors.Errorf("Value in field \"action\" was too long")
4206 }
4207
4208 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("action"))); err != nil {
4209 return err
4210 }
4211 if _, err := cw.WriteString(string("action")); err != nil {
4212 return err
4213 }
4214
4215 if len(t.Action) > 1000000 {
4216 return xerrors.Errorf("Value in field t.Action was too long")
4217 }
4218
4219 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Action))); err != nil {
4220 return err
4221 }
4222 if _, err := cw.WriteString(string(t.Action)); err != nil {
4223 return err
4224 }
4225
4226 // t.SourceSha (string) (string)
4227 if len("sourceSha") > 1000000 {
4228 return xerrors.Errorf("Value in field \"sourceSha\" was too long")
4229 }
4230
4231 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceSha"))); err != nil {
4232 return err
4233 }
4234 if _, err := cw.WriteString(string("sourceSha")); err != nil {
4235 return err
4236 }
4237
4238 if len(t.SourceSha) > 1000000 {
4239 return xerrors.Errorf("Value in field t.SourceSha was too long")
4240 }
4241
4242 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceSha))); err != nil {
4243 return err
4244 }
4245 if _, err := cw.WriteString(string(t.SourceSha)); err != nil {
4246 return err
4247 }
4248
4249 // t.SourceBranch (string) (string)
4250 if len("sourceBranch") > 1000000 {
4251 return xerrors.Errorf("Value in field \"sourceBranch\" was too long")
4252 }
4253
4254 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceBranch"))); err != nil {
4255 return err
4256 }
4257 if _, err := cw.WriteString(string("sourceBranch")); err != nil {
4258 return err
4259 }
4260
4261 if len(t.SourceBranch) > 1000000 {
4262 return xerrors.Errorf("Value in field t.SourceBranch was too long")
4263 }
4264
4265 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceBranch))); err != nil {
4266 return err
4267 }
4268 if _, err := cw.WriteString(string(t.SourceBranch)); err != nil {
4269 return err
4270 }
4271
4272 // t.TargetBranch (string) (string)
4273 if len("targetBranch") > 1000000 {
4274 return xerrors.Errorf("Value in field \"targetBranch\" was too long")
4275 }
4276
4277 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil {
4278 return err
4279 }
4280 if _, err := cw.WriteString(string("targetBranch")); err != nil {
4281 return err
4282 }
4283
4284 if len(t.TargetBranch) > 1000000 {
4285 return xerrors.Errorf("Value in field t.TargetBranch was too long")
4286 }
4287
4288 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil {
4289 return err
4290 }
4291 if _, err := cw.WriteString(string(t.TargetBranch)); err != nil {
4292 return err
4293 }
4294 return nil
4295}
4296
4297func (t *Pipeline_PullRequestTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
4298 *t = Pipeline_PullRequestTriggerData{}
4299
4300 cr := cbg.NewCborReader(r)
4301
4302 maj, extra, err := cr.ReadHeader()
4303 if err != nil {
4304 return err
4305 }
4306 defer func() {
4307 if err == io.EOF {
4308 err = io.ErrUnexpectedEOF
4309 }
4310 }()
4311
4312 if maj != cbg.MajMap {
4313 return fmt.Errorf("cbor input should be of type map")
4314 }
4315
4316 if extra > cbg.MaxLength {
4317 return fmt.Errorf("Pipeline_PullRequestTriggerData: map struct too large (%d)", extra)
4318 }
4319
4320 n := extra
4321
4322 nameBuf := make([]byte, 12)
4323 for i := uint64(0); i < n; i++ {
4324 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4325 if err != nil {
4326 return err
4327 }
4328
4329 if !ok {
4330 // Field doesn't exist on this type, so ignore it
4331 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4332 return err
4333 }
4334 continue
4335 }
4336
4337 switch string(nameBuf[:nameLen]) {
4338 // t.Action (string) (string)
4339 case "action":
4340
4341 {
4342 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4343 if err != nil {
4344 return err
4345 }
4346
4347 t.Action = string(sval)
4348 }
4349 // t.SourceSha (string) (string)
4350 case "sourceSha":
4351
4352 {
4353 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4354 if err != nil {
4355 return err
4356 }
4357
4358 t.SourceSha = string(sval)
4359 }
4360 // t.SourceBranch (string) (string)
4361 case "sourceBranch":
4362
4363 {
4364 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4365 if err != nil {
4366 return err
4367 }
4368
4369 t.SourceBranch = string(sval)
4370 }
4371 // t.TargetBranch (string) (string)
4372 case "targetBranch":
4373
4374 {
4375 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4376 if err != nil {
4377 return err
4378 }
4379
4380 t.TargetBranch = string(sval)
4381 }
4382
4383 default:
4384 // Field doesn't exist on this type, so ignore it
4385 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4386 return err
4387 }
4388 }
4389 }
4390
4391 return nil
4392}
4393func (t *Pipeline_PushTriggerData) MarshalCBOR(w io.Writer) error {
4394 if t == nil {
4395 _, err := w.Write(cbg.CborNull)
4396 return err
4397 }
4398
4399 cw := cbg.NewCborWriter(w)
4400
4401 if _, err := cw.Write([]byte{163}); err != nil {
4402 return err
4403 }
4404
4405 // t.Ref (string) (string)
4406 if len("ref") > 1000000 {
4407 return xerrors.Errorf("Value in field \"ref\" was too long")
4408 }
4409
4410 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
4411 return err
4412 }
4413 if _, err := cw.WriteString(string("ref")); err != nil {
4414 return err
4415 }
4416
4417 if len(t.Ref) > 1000000 {
4418 return xerrors.Errorf("Value in field t.Ref was too long")
4419 }
4420
4421 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
4422 return err
4423 }
4424 if _, err := cw.WriteString(string(t.Ref)); err != nil {
4425 return err
4426 }
4427
4428 // t.NewSha (string) (string)
4429 if len("newSha") > 1000000 {
4430 return xerrors.Errorf("Value in field \"newSha\" was too long")
4431 }
4432
4433 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
4434 return err
4435 }
4436 if _, err := cw.WriteString(string("newSha")); err != nil {
4437 return err
4438 }
4439
4440 if len(t.NewSha) > 1000000 {
4441 return xerrors.Errorf("Value in field t.NewSha was too long")
4442 }
4443
4444 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
4445 return err
4446 }
4447 if _, err := cw.WriteString(string(t.NewSha)); err != nil {
4448 return err
4449 }
4450
4451 // t.OldSha (string) (string)
4452 if len("oldSha") > 1000000 {
4453 return xerrors.Errorf("Value in field \"oldSha\" was too long")
4454 }
4455
4456 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
4457 return err
4458 }
4459 if _, err := cw.WriteString(string("oldSha")); err != nil {
4460 return err
4461 }
4462
4463 if len(t.OldSha) > 1000000 {
4464 return xerrors.Errorf("Value in field t.OldSha was too long")
4465 }
4466
4467 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
4468 return err
4469 }
4470 if _, err := cw.WriteString(string(t.OldSha)); err != nil {
4471 return err
4472 }
4473 return nil
4474}
4475
4476func (t *Pipeline_PushTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
4477 *t = Pipeline_PushTriggerData{}
4478
4479 cr := cbg.NewCborReader(r)
4480
4481 maj, extra, err := cr.ReadHeader()
4482 if err != nil {
4483 return err
4484 }
4485 defer func() {
4486 if err == io.EOF {
4487 err = io.ErrUnexpectedEOF
4488 }
4489 }()
4490
4491 if maj != cbg.MajMap {
4492 return fmt.Errorf("cbor input should be of type map")
4493 }
4494
4495 if extra > cbg.MaxLength {
4496 return fmt.Errorf("Pipeline_PushTriggerData: map struct too large (%d)", extra)
4497 }
4498
4499 n := extra
4500
4501 nameBuf := make([]byte, 6)
4502 for i := uint64(0); i < n; i++ {
4503 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4504 if err != nil {
4505 return err
4506 }
4507
4508 if !ok {
4509 // Field doesn't exist on this type, so ignore it
4510 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4511 return err
4512 }
4513 continue
4514 }
4515
4516 switch string(nameBuf[:nameLen]) {
4517 // t.Ref (string) (string)
4518 case "ref":
4519
4520 {
4521 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4522 if err != nil {
4523 return err
4524 }
4525
4526 t.Ref = string(sval)
4527 }
4528 // t.NewSha (string) (string)
4529 case "newSha":
4530
4531 {
4532 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4533 if err != nil {
4534 return err
4535 }
4536
4537 t.NewSha = string(sval)
4538 }
4539 // t.OldSha (string) (string)
4540 case "oldSha":
4541
4542 {
4543 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4544 if err != nil {
4545 return err
4546 }
4547
4548 t.OldSha = string(sval)
4549 }
4550
4551 default:
4552 // Field doesn't exist on this type, so ignore it
4553 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4554 return err
4555 }
4556 }
4557 }
4558
4559 return nil
4560}
4561func (t *PipelineStatus) MarshalCBOR(w io.Writer) error {
4562 if t == nil {
4563 _, err := w.Write(cbg.CborNull)
4564 return err
4565 }
4566
4567 cw := cbg.NewCborWriter(w)
4568 fieldCount := 7
4569
4570 if t.Error == nil {
4571 fieldCount--
4572 }
4573
4574 if t.ExitCode == nil {
4575 fieldCount--
4576 }
4577
4578 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4579 return err
4580 }
4581
4582 // t.LexiconTypeID (string) (string)
4583 if len("$type") > 1000000 {
4584 return xerrors.Errorf("Value in field \"$type\" was too long")
4585 }
4586
4587 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
4588 return err
4589 }
4590 if _, err := cw.WriteString(string("$type")); err != nil {
4591 return err
4592 }
4593
4594 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline.status"))); err != nil {
4595 return err
4596 }
4597 if _, err := cw.WriteString(string("sh.tangled.pipeline.status")); err != nil {
4598 return err
4599 }
4600
4601 // t.Error (string) (string)
4602 if t.Error != nil {
4603
4604 if len("error") > 1000000 {
4605 return xerrors.Errorf("Value in field \"error\" was too long")
4606 }
4607
4608 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("error"))); err != nil {
4609 return err
4610 }
4611 if _, err := cw.WriteString(string("error")); err != nil {
4612 return err
4613 }
4614
4615 if t.Error == nil {
4616 if _, err := cw.Write(cbg.CborNull); err != nil {
4617 return err
4618 }
4619 } else {
4620 if len(*t.Error) > 1000000 {
4621 return xerrors.Errorf("Value in field t.Error was too long")
4622 }
4623
4624 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Error))); err != nil {
4625 return err
4626 }
4627 if _, err := cw.WriteString(string(*t.Error)); err != nil {
4628 return err
4629 }
4630 }
4631 }
4632
4633 // t.Status (string) (string)
4634 if len("status") > 1000000 {
4635 return xerrors.Errorf("Value in field \"status\" was too long")
4636 }
4637
4638 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
4639 return err
4640 }
4641 if _, err := cw.WriteString(string("status")); err != nil {
4642 return err
4643 }
4644
4645 if len(t.Status) > 1000000 {
4646 return xerrors.Errorf("Value in field t.Status was too long")
4647 }
4648
4649 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
4650 return err
4651 }
4652 if _, err := cw.WriteString(string(t.Status)); err != nil {
4653 return err
4654 }
4655
4656 // t.ExitCode (int64) (int64)
4657 if t.ExitCode != nil {
4658
4659 if len("exitCode") > 1000000 {
4660 return xerrors.Errorf("Value in field \"exitCode\" was too long")
4661 }
4662
4663 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("exitCode"))); err != nil {
4664 return err
4665 }
4666 if _, err := cw.WriteString(string("exitCode")); err != nil {
4667 return err
4668 }
4669
4670 if t.ExitCode == nil {
4671 if _, err := cw.Write(cbg.CborNull); err != nil {
4672 return err
4673 }
4674 } else {
4675 if *t.ExitCode >= 0 {
4676 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.ExitCode)); err != nil {
4677 return err
4678 }
4679 } else {
4680 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.ExitCode-1)); err != nil {
4681 return err
4682 }
4683 }
4684 }
4685
4686 }
4687
4688 // t.Pipeline (string) (string)
4689 if len("pipeline") > 1000000 {
4690 return xerrors.Errorf("Value in field \"pipeline\" was too long")
4691 }
4692
4693 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pipeline"))); err != nil {
4694 return err
4695 }
4696 if _, err := cw.WriteString(string("pipeline")); err != nil {
4697 return err
4698 }
4699
4700 if len(t.Pipeline) > 1000000 {
4701 return xerrors.Errorf("Value in field t.Pipeline was too long")
4702 }
4703
4704 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pipeline))); err != nil {
4705 return err
4706 }
4707 if _, err := cw.WriteString(string(t.Pipeline)); err != nil {
4708 return err
4709 }
4710
4711 // t.Workflow (string) (string)
4712 if len("workflow") > 1000000 {
4713 return xerrors.Errorf("Value in field \"workflow\" was too long")
4714 }
4715
4716 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil {
4717 return err
4718 }
4719 if _, err := cw.WriteString(string("workflow")); err != nil {
4720 return err
4721 }
4722
4723 if len(t.Workflow) > 1000000 {
4724 return xerrors.Errorf("Value in field t.Workflow was too long")
4725 }
4726
4727 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil {
4728 return err
4729 }
4730 if _, err := cw.WriteString(string(t.Workflow)); err != nil {
4731 return err
4732 }
4733
4734 // t.CreatedAt (string) (string)
4735 if len("createdAt") > 1000000 {
4736 return xerrors.Errorf("Value in field \"createdAt\" was too long")
4737 }
4738
4739 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
4740 return err
4741 }
4742 if _, err := cw.WriteString(string("createdAt")); err != nil {
4743 return err
4744 }
4745
4746 if len(t.CreatedAt) > 1000000 {
4747 return xerrors.Errorf("Value in field t.CreatedAt was too long")
4748 }
4749
4750 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
4751 return err
4752 }
4753 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
4754 return err
4755 }
4756 return nil
4757}
4758
4759func (t *PipelineStatus) UnmarshalCBOR(r io.Reader) (err error) {
4760 *t = PipelineStatus{}
4761
4762 cr := cbg.NewCborReader(r)
4763
4764 maj, extra, err := cr.ReadHeader()
4765 if err != nil {
4766 return err
4767 }
4768 defer func() {
4769 if err == io.EOF {
4770 err = io.ErrUnexpectedEOF
4771 }
4772 }()
4773
4774 if maj != cbg.MajMap {
4775 return fmt.Errorf("cbor input should be of type map")
4776 }
4777
4778 if extra > cbg.MaxLength {
4779 return fmt.Errorf("PipelineStatus: map struct too large (%d)", extra)
4780 }
4781
4782 n := extra
4783
4784 nameBuf := make([]byte, 9)
4785 for i := uint64(0); i < n; i++ {
4786 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4787 if err != nil {
4788 return err
4789 }
4790
4791 if !ok {
4792 // Field doesn't exist on this type, so ignore it
4793 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4794 return err
4795 }
4796 continue
4797 }
4798
4799 switch string(nameBuf[:nameLen]) {
4800 // t.LexiconTypeID (string) (string)
4801 case "$type":
4802
4803 {
4804 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4805 if err != nil {
4806 return err
4807 }
4808
4809 t.LexiconTypeID = string(sval)
4810 }
4811 // t.Error (string) (string)
4812 case "error":
4813
4814 {
4815 b, err := cr.ReadByte()
4816 if err != nil {
4817 return err
4818 }
4819 if b != cbg.CborNull[0] {
4820 if err := cr.UnreadByte(); err != nil {
4821 return err
4822 }
4823
4824 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4825 if err != nil {
4826 return err
4827 }
4828
4829 t.Error = (*string)(&sval)
4830 }
4831 }
4832 // t.Status (string) (string)
4833 case "status":
4834
4835 {
4836 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4837 if err != nil {
4838 return err
4839 }
4840
4841 t.Status = string(sval)
4842 }
4843 // t.ExitCode (int64) (int64)
4844 case "exitCode":
4845 {
4846
4847 b, err := cr.ReadByte()
4848 if err != nil {
4849 return err
4850 }
4851 if b != cbg.CborNull[0] {
4852 if err := cr.UnreadByte(); err != nil {
4853 return err
4854 }
4855 maj, extra, err := cr.ReadHeader()
4856 if err != nil {
4857 return err
4858 }
4859 var extraI int64
4860 switch maj {
4861 case cbg.MajUnsignedInt:
4862 extraI = int64(extra)
4863 if extraI < 0 {
4864 return fmt.Errorf("int64 positive overflow")
4865 }
4866 case cbg.MajNegativeInt:
4867 extraI = int64(extra)
4868 if extraI < 0 {
4869 return fmt.Errorf("int64 negative overflow")
4870 }
4871 extraI = -1 - extraI
4872 default:
4873 return fmt.Errorf("wrong type for int64 field: %d", maj)
4874 }
4875
4876 t.ExitCode = (*int64)(&extraI)
4877 }
4878 }
4879 // t.Pipeline (string) (string)
4880 case "pipeline":
4881
4882 {
4883 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4884 if err != nil {
4885 return err
4886 }
4887
4888 t.Pipeline = string(sval)
4889 }
4890 // t.Workflow (string) (string)
4891 case "workflow":
4892
4893 {
4894 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4895 if err != nil {
4896 return err
4897 }
4898
4899 t.Workflow = string(sval)
4900 }
4901 // t.CreatedAt (string) (string)
4902 case "createdAt":
4903
4904 {
4905 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4906 if err != nil {
4907 return err
4908 }
4909
4910 t.CreatedAt = string(sval)
4911 }
4912
4913 default:
4914 // Field doesn't exist on this type, so ignore it
4915 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4916 return err
4917 }
4918 }
4919 }
4920
4921 return nil
4922}
4923func (t *Pipeline_TriggerMetadata) MarshalCBOR(w io.Writer) error {
4924 if t == nil {
4925 _, err := w.Write(cbg.CborNull)
4926 return err
4927 }
4928
4929 cw := cbg.NewCborWriter(w)
4930 fieldCount := 5
4931
4932 if t.Manual == nil {
4933 fieldCount--
4934 }
4935
4936 if t.PullRequest == nil {
4937 fieldCount--
4938 }
4939
4940 if t.Push == nil {
4941 fieldCount--
4942 }
4943
4944 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4945 return err
4946 }
4947
4948 // t.Kind (string) (string)
4949 if len("kind") > 1000000 {
4950 return xerrors.Errorf("Value in field \"kind\" was too long")
4951 }
4952
4953 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("kind"))); err != nil {
4954 return err
4955 }
4956 if _, err := cw.WriteString(string("kind")); err != nil {
4957 return err
4958 }
4959
4960 if len(t.Kind) > 1000000 {
4961 return xerrors.Errorf("Value in field t.Kind was too long")
4962 }
4963
4964 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Kind))); err != nil {
4965 return err
4966 }
4967 if _, err := cw.WriteString(string(t.Kind)); err != nil {
4968 return err
4969 }
4970
4971 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
4972 if t.Push != nil {
4973
4974 if len("push") > 1000000 {
4975 return xerrors.Errorf("Value in field \"push\" was too long")
4976 }
4977
4978 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("push"))); err != nil {
4979 return err
4980 }
4981 if _, err := cw.WriteString(string("push")); err != nil {
4982 return err
4983 }
4984
4985 if err := t.Push.MarshalCBOR(cw); err != nil {
4986 return err
4987 }
4988 }
4989
4990 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
4991 if len("repo") > 1000000 {
4992 return xerrors.Errorf("Value in field \"repo\" was too long")
4993 }
4994
4995 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
4996 return err
4997 }
4998 if _, err := cw.WriteString(string("repo")); err != nil {
4999 return err
5000 }
5001
5002 if err := t.Repo.MarshalCBOR(cw); err != nil {
5003 return err
5004 }
5005
5006 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
5007 if t.Manual != nil {
5008
5009 if len("manual") > 1000000 {
5010 return xerrors.Errorf("Value in field \"manual\" was too long")
5011 }
5012
5013 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("manual"))); err != nil {
5014 return err
5015 }
5016 if _, err := cw.WriteString(string("manual")); err != nil {
5017 return err
5018 }
5019
5020 if err := t.Manual.MarshalCBOR(cw); err != nil {
5021 return err
5022 }
5023 }
5024
5025 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
5026 if t.PullRequest != nil {
5027
5028 if len("pullRequest") > 1000000 {
5029 return xerrors.Errorf("Value in field \"pullRequest\" was too long")
5030 }
5031
5032 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullRequest"))); err != nil {
5033 return err
5034 }
5035 if _, err := cw.WriteString(string("pullRequest")); err != nil {
5036 return err
5037 }
5038
5039 if err := t.PullRequest.MarshalCBOR(cw); err != nil {
5040 return err
5041 }
5042 }
5043 return nil
5044}
5045
5046func (t *Pipeline_TriggerMetadata) UnmarshalCBOR(r io.Reader) (err error) {
5047 *t = Pipeline_TriggerMetadata{}
5048
5049 cr := cbg.NewCborReader(r)
5050
5051 maj, extra, err := cr.ReadHeader()
5052 if err != nil {
5053 return err
5054 }
5055 defer func() {
5056 if err == io.EOF {
5057 err = io.ErrUnexpectedEOF
5058 }
5059 }()
5060
5061 if maj != cbg.MajMap {
5062 return fmt.Errorf("cbor input should be of type map")
5063 }
5064
5065 if extra > cbg.MaxLength {
5066 return fmt.Errorf("Pipeline_TriggerMetadata: map struct too large (%d)", extra)
5067 }
5068
5069 n := extra
5070
5071 nameBuf := make([]byte, 11)
5072 for i := uint64(0); i < n; i++ {
5073 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5074 if err != nil {
5075 return err
5076 }
5077
5078 if !ok {
5079 // Field doesn't exist on this type, so ignore it
5080 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5081 return err
5082 }
5083 continue
5084 }
5085
5086 switch string(nameBuf[:nameLen]) {
5087 // t.Kind (string) (string)
5088 case "kind":
5089
5090 {
5091 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5092 if err != nil {
5093 return err
5094 }
5095
5096 t.Kind = string(sval)
5097 }
5098 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
5099 case "push":
5100
5101 {
5102
5103 b, err := cr.ReadByte()
5104 if err != nil {
5105 return err
5106 }
5107 if b != cbg.CborNull[0] {
5108 if err := cr.UnreadByte(); err != nil {
5109 return err
5110 }
5111 t.Push = new(Pipeline_PushTriggerData)
5112 if err := t.Push.UnmarshalCBOR(cr); err != nil {
5113 return xerrors.Errorf("unmarshaling t.Push pointer: %w", err)
5114 }
5115 }
5116
5117 }
5118 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
5119 case "repo":
5120
5121 {
5122
5123 b, err := cr.ReadByte()
5124 if err != nil {
5125 return err
5126 }
5127 if b != cbg.CborNull[0] {
5128 if err := cr.UnreadByte(); err != nil {
5129 return err
5130 }
5131 t.Repo = new(Pipeline_TriggerRepo)
5132 if err := t.Repo.UnmarshalCBOR(cr); err != nil {
5133 return xerrors.Errorf("unmarshaling t.Repo pointer: %w", err)
5134 }
5135 }
5136
5137 }
5138 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
5139 case "manual":
5140
5141 {
5142
5143 b, err := cr.ReadByte()
5144 if err != nil {
5145 return err
5146 }
5147 if b != cbg.CborNull[0] {
5148 if err := cr.UnreadByte(); err != nil {
5149 return err
5150 }
5151 t.Manual = new(Pipeline_ManualTriggerData)
5152 if err := t.Manual.UnmarshalCBOR(cr); err != nil {
5153 return xerrors.Errorf("unmarshaling t.Manual pointer: %w", err)
5154 }
5155 }
5156
5157 }
5158 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
5159 case "pullRequest":
5160
5161 {
5162
5163 b, err := cr.ReadByte()
5164 if err != nil {
5165 return err
5166 }
5167 if b != cbg.CborNull[0] {
5168 if err := cr.UnreadByte(); err != nil {
5169 return err
5170 }
5171 t.PullRequest = new(Pipeline_PullRequestTriggerData)
5172 if err := t.PullRequest.UnmarshalCBOR(cr); err != nil {
5173 return xerrors.Errorf("unmarshaling t.PullRequest pointer: %w", err)
5174 }
5175 }
5176
5177 }
5178
5179 default:
5180 // Field doesn't exist on this type, so ignore it
5181 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5182 return err
5183 }
5184 }
5185 }
5186
5187 return nil
5188}
5189func (t *Pipeline_TriggerRepo) MarshalCBOR(w io.Writer) error {
5190 if t == nil {
5191 _, err := w.Write(cbg.CborNull)
5192 return err
5193 }
5194
5195 cw := cbg.NewCborWriter(w)
5196
5197 if _, err := cw.Write([]byte{164}); err != nil {
5198 return err
5199 }
5200
5201 // t.Did (string) (string)
5202 if len("did") > 1000000 {
5203 return xerrors.Errorf("Value in field \"did\" was too long")
5204 }
5205
5206 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil {
5207 return err
5208 }
5209 if _, err := cw.WriteString(string("did")); err != nil {
5210 return err
5211 }
5212
5213 if len(t.Did) > 1000000 {
5214 return xerrors.Errorf("Value in field t.Did was too long")
5215 }
5216
5217 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil {
5218 return err
5219 }
5220 if _, err := cw.WriteString(string(t.Did)); err != nil {
5221 return err
5222 }
5223
5224 // t.Knot (string) (string)
5225 if len("knot") > 1000000 {
5226 return xerrors.Errorf("Value in field \"knot\" was too long")
5227 }
5228
5229 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
5230 return err
5231 }
5232 if _, err := cw.WriteString(string("knot")); err != nil {
5233 return err
5234 }
5235
5236 if len(t.Knot) > 1000000 {
5237 return xerrors.Errorf("Value in field t.Knot was too long")
5238 }
5239
5240 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
5241 return err
5242 }
5243 if _, err := cw.WriteString(string(t.Knot)); err != nil {
5244 return err
5245 }
5246
5247 // t.Repo (string) (string)
5248 if len("repo") > 1000000 {
5249 return xerrors.Errorf("Value in field \"repo\" was too long")
5250 }
5251
5252 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5253 return err
5254 }
5255 if _, err := cw.WriteString(string("repo")); err != nil {
5256 return err
5257 }
5258
5259 if len(t.Repo) > 1000000 {
5260 return xerrors.Errorf("Value in field t.Repo was too long")
5261 }
5262
5263 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
5264 return err
5265 }
5266 if _, err := cw.WriteString(string(t.Repo)); err != nil {
5267 return err
5268 }
5269
5270 // t.DefaultBranch (string) (string)
5271 if len("defaultBranch") > 1000000 {
5272 return xerrors.Errorf("Value in field \"defaultBranch\" was too long")
5273 }
5274
5275 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("defaultBranch"))); err != nil {
5276 return err
5277 }
5278 if _, err := cw.WriteString(string("defaultBranch")); err != nil {
5279 return err
5280 }
5281
5282 if len(t.DefaultBranch) > 1000000 {
5283 return xerrors.Errorf("Value in field t.DefaultBranch was too long")
5284 }
5285
5286 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.DefaultBranch))); err != nil {
5287 return err
5288 }
5289 if _, err := cw.WriteString(string(t.DefaultBranch)); err != nil {
5290 return err
5291 }
5292 return nil
5293}
5294
5295func (t *Pipeline_TriggerRepo) UnmarshalCBOR(r io.Reader) (err error) {
5296 *t = Pipeline_TriggerRepo{}
5297
5298 cr := cbg.NewCborReader(r)
5299
5300 maj, extra, err := cr.ReadHeader()
5301 if err != nil {
5302 return err
5303 }
5304 defer func() {
5305 if err == io.EOF {
5306 err = io.ErrUnexpectedEOF
5307 }
5308 }()
5309
5310 if maj != cbg.MajMap {
5311 return fmt.Errorf("cbor input should be of type map")
5312 }
5313
5314 if extra > cbg.MaxLength {
5315 return fmt.Errorf("Pipeline_TriggerRepo: map struct too large (%d)", extra)
5316 }
5317
5318 n := extra
5319
5320 nameBuf := make([]byte, 13)
5321 for i := uint64(0); i < n; i++ {
5322 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5323 if err != nil {
5324 return err
5325 }
5326
5327 if !ok {
5328 // Field doesn't exist on this type, so ignore it
5329 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5330 return err
5331 }
5332 continue
5333 }
5334
5335 switch string(nameBuf[:nameLen]) {
5336 // t.Did (string) (string)
5337 case "did":
5338
5339 {
5340 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5341 if err != nil {
5342 return err
5343 }
5344
5345 t.Did = string(sval)
5346 }
5347 // t.Knot (string) (string)
5348 case "knot":
5349
5350 {
5351 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5352 if err != nil {
5353 return err
5354 }
5355
5356 t.Knot = string(sval)
5357 }
5358 // t.Repo (string) (string)
5359 case "repo":
5360
5361 {
5362 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5363 if err != nil {
5364 return err
5365 }
5366
5367 t.Repo = string(sval)
5368 }
5369 // t.DefaultBranch (string) (string)
5370 case "defaultBranch":
5371
5372 {
5373 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5374 if err != nil {
5375 return err
5376 }
5377
5378 t.DefaultBranch = string(sval)
5379 }
5380
5381 default:
5382 // Field doesn't exist on this type, so ignore it
5383 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5384 return err
5385 }
5386 }
5387 }
5388
5389 return nil
5390}
5391func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error {
5392 if t == nil {
5393 _, err := w.Write(cbg.CborNull)
5394 return err
5395 }
5396
5397 cw := cbg.NewCborWriter(w)
5398
5399 if _, err := cw.Write([]byte{164}); err != nil {
5400 return err
5401 }
5402
5403 // t.Raw (string) (string)
5404 if len("raw") > 1000000 {
5405 return xerrors.Errorf("Value in field \"raw\" was too long")
5406 }
5407
5408 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("raw"))); err != nil {
5409 return err
5410 }
5411 if _, err := cw.WriteString(string("raw")); err != nil {
5412 return err
5413 }
5414
5415 if len(t.Raw) > 1000000 {
5416 return xerrors.Errorf("Value in field t.Raw was too long")
5417 }
5418
5419 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Raw))); err != nil {
5420 return err
5421 }
5422 if _, err := cw.WriteString(string(t.Raw)); err != nil {
5423 return err
5424 }
5425
5426 // t.Name (string) (string)
5427 if len("name") > 1000000 {
5428 return xerrors.Errorf("Value in field \"name\" was too long")
5429 }
5430
5431 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5432 return err
5433 }
5434 if _, err := cw.WriteString(string("name")); err != nil {
5435 return err
5436 }
5437
5438 if len(t.Name) > 1000000 {
5439 return xerrors.Errorf("Value in field t.Name was too long")
5440 }
5441
5442 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5443 return err
5444 }
5445 if _, err := cw.WriteString(string(t.Name)); err != nil {
5446 return err
5447 }
5448
5449 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
5450 if len("clone") > 1000000 {
5451 return xerrors.Errorf("Value in field \"clone\" was too long")
5452 }
5453
5454 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil {
5455 return err
5456 }
5457 if _, err := cw.WriteString(string("clone")); err != nil {
5458 return err
5459 }
5460
5461 if err := t.Clone.MarshalCBOR(cw); err != nil {
5462 return err
5463 }
5464
5465 // t.Engine (string) (string)
5466 if len("engine") > 1000000 {
5467 return xerrors.Errorf("Value in field \"engine\" was too long")
5468 }
5469
5470 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("engine"))); err != nil {
5471 return err
5472 }
5473 if _, err := cw.WriteString(string("engine")); err != nil {
5474 return err
5475 }
5476
5477 if len(t.Engine) > 1000000 {
5478 return xerrors.Errorf("Value in field t.Engine was too long")
5479 }
5480
5481 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Engine))); err != nil {
5482 return err
5483 }
5484 if _, err := cw.WriteString(string(t.Engine)); err != nil {
5485 return err
5486 }
5487 return nil
5488}
5489
5490func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) {
5491 *t = Pipeline_Workflow{}
5492
5493 cr := cbg.NewCborReader(r)
5494
5495 maj, extra, err := cr.ReadHeader()
5496 if err != nil {
5497 return err
5498 }
5499 defer func() {
5500 if err == io.EOF {
5501 err = io.ErrUnexpectedEOF
5502 }
5503 }()
5504
5505 if maj != cbg.MajMap {
5506 return fmt.Errorf("cbor input should be of type map")
5507 }
5508
5509 if extra > cbg.MaxLength {
5510 return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra)
5511 }
5512
5513 n := extra
5514
5515 nameBuf := make([]byte, 6)
5516 for i := uint64(0); i < n; i++ {
5517 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5518 if err != nil {
5519 return err
5520 }
5521
5522 if !ok {
5523 // Field doesn't exist on this type, so ignore it
5524 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5525 return err
5526 }
5527 continue
5528 }
5529
5530 switch string(nameBuf[:nameLen]) {
5531 // t.Raw (string) (string)
5532 case "raw":
5533
5534 {
5535 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5536 if err != nil {
5537 return err
5538 }
5539
5540 t.Raw = string(sval)
5541 }
5542 // t.Name (string) (string)
5543 case "name":
5544
5545 {
5546 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5547 if err != nil {
5548 return err
5549 }
5550
5551 t.Name = string(sval)
5552 }
5553 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
5554 case "clone":
5555
5556 {
5557
5558 b, err := cr.ReadByte()
5559 if err != nil {
5560 return err
5561 }
5562 if b != cbg.CborNull[0] {
5563 if err := cr.UnreadByte(); err != nil {
5564 return err
5565 }
5566 t.Clone = new(Pipeline_CloneOpts)
5567 if err := t.Clone.UnmarshalCBOR(cr); err != nil {
5568 return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err)
5569 }
5570 }
5571
5572 }
5573 // t.Engine (string) (string)
5574 case "engine":
5575
5576 {
5577 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5578 if err != nil {
5579 return err
5580 }
5581
5582 t.Engine = string(sval)
5583 }
5584
5585 default:
5586 // Field doesn't exist on this type, so ignore it
5587 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5588 return err
5589 }
5590 }
5591 }
5592
5593 return nil
5594}
5595func (t *PublicKey) MarshalCBOR(w io.Writer) error {
5596 if t == nil {
5597 _, err := w.Write(cbg.CborNull)
5598 return err
5599 }
5600
5601 cw := cbg.NewCborWriter(w)
5602
5603 if _, err := cw.Write([]byte{164}); err != nil {
5604 return err
5605 }
5606
5607 // t.Key (string) (string)
5608 if len("key") > 1000000 {
5609 return xerrors.Errorf("Value in field \"key\" was too long")
5610 }
5611
5612 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
5613 return err
5614 }
5615 if _, err := cw.WriteString(string("key")); err != nil {
5616 return err
5617 }
5618
5619 if len(t.Key) > 1000000 {
5620 return xerrors.Errorf("Value in field t.Key was too long")
5621 }
5622
5623 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
5624 return err
5625 }
5626 if _, err := cw.WriteString(string(t.Key)); err != nil {
5627 return err
5628 }
5629
5630 // t.Name (string) (string)
5631 if len("name") > 1000000 {
5632 return xerrors.Errorf("Value in field \"name\" was too long")
5633 }
5634
5635 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5636 return err
5637 }
5638 if _, err := cw.WriteString(string("name")); err != nil {
5639 return err
5640 }
5641
5642 if len(t.Name) > 1000000 {
5643 return xerrors.Errorf("Value in field t.Name was too long")
5644 }
5645
5646 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5647 return err
5648 }
5649 if _, err := cw.WriteString(string(t.Name)); err != nil {
5650 return err
5651 }
5652
5653 // t.LexiconTypeID (string) (string)
5654 if len("$type") > 1000000 {
5655 return xerrors.Errorf("Value in field \"$type\" was too long")
5656 }
5657
5658 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5659 return err
5660 }
5661 if _, err := cw.WriteString(string("$type")); err != nil {
5662 return err
5663 }
5664
5665 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil {
5666 return err
5667 }
5668 if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil {
5669 return err
5670 }
5671
5672 // t.CreatedAt (string) (string)
5673 if len("createdAt") > 1000000 {
5674 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5675 }
5676
5677 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5678 return err
5679 }
5680 if _, err := cw.WriteString(string("createdAt")); err != nil {
5681 return err
5682 }
5683
5684 if len(t.CreatedAt) > 1000000 {
5685 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5686 }
5687
5688 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5689 return err
5690 }
5691 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5692 return err
5693 }
5694 return nil
5695}
5696
5697func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) {
5698 *t = PublicKey{}
5699
5700 cr := cbg.NewCborReader(r)
5701
5702 maj, extra, err := cr.ReadHeader()
5703 if err != nil {
5704 return err
5705 }
5706 defer func() {
5707 if err == io.EOF {
5708 err = io.ErrUnexpectedEOF
5709 }
5710 }()
5711
5712 if maj != cbg.MajMap {
5713 return fmt.Errorf("cbor input should be of type map")
5714 }
5715
5716 if extra > cbg.MaxLength {
5717 return fmt.Errorf("PublicKey: map struct too large (%d)", extra)
5718 }
5719
5720 n := extra
5721
5722 nameBuf := make([]byte, 9)
5723 for i := uint64(0); i < n; i++ {
5724 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5725 if err != nil {
5726 return err
5727 }
5728
5729 if !ok {
5730 // Field doesn't exist on this type, so ignore it
5731 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5732 return err
5733 }
5734 continue
5735 }
5736
5737 switch string(nameBuf[:nameLen]) {
5738 // t.Key (string) (string)
5739 case "key":
5740
5741 {
5742 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5743 if err != nil {
5744 return err
5745 }
5746
5747 t.Key = string(sval)
5748 }
5749 // t.Name (string) (string)
5750 case "name":
5751
5752 {
5753 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5754 if err != nil {
5755 return err
5756 }
5757
5758 t.Name = string(sval)
5759 }
5760 // t.LexiconTypeID (string) (string)
5761 case "$type":
5762
5763 {
5764 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5765 if err != nil {
5766 return err
5767 }
5768
5769 t.LexiconTypeID = string(sval)
5770 }
5771 // t.CreatedAt (string) (string)
5772 case "createdAt":
5773
5774 {
5775 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5776 if err != nil {
5777 return err
5778 }
5779
5780 t.CreatedAt = string(sval)
5781 }
5782
5783 default:
5784 // Field doesn't exist on this type, so ignore it
5785 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5786 return err
5787 }
5788 }
5789 }
5790
5791 return nil
5792}
5793func (t *Repo) MarshalCBOR(w io.Writer) error {
5794 if t == nil {
5795 _, err := w.Write(cbg.CborNull)
5796 return err
5797 }
5798
5799 cw := cbg.NewCborWriter(w)
5800 fieldCount := 8
5801
5802 if t.Description == nil {
5803 fieldCount--
5804 }
5805
5806 if t.Labels == nil {
5807 fieldCount--
5808 }
5809
5810 if t.Source == nil {
5811 fieldCount--
5812 }
5813
5814 if t.Spindle == nil {
5815 fieldCount--
5816 }
5817
5818 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5819 return err
5820 }
5821
5822 // t.Knot (string) (string)
5823 if len("knot") > 1000000 {
5824 return xerrors.Errorf("Value in field \"knot\" was too long")
5825 }
5826
5827 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
5828 return err
5829 }
5830 if _, err := cw.WriteString(string("knot")); err != nil {
5831 return err
5832 }
5833
5834 if len(t.Knot) > 1000000 {
5835 return xerrors.Errorf("Value in field t.Knot was too long")
5836 }
5837
5838 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
5839 return err
5840 }
5841 if _, err := cw.WriteString(string(t.Knot)); err != nil {
5842 return err
5843 }
5844
5845 // t.Name (string) (string)
5846 if len("name") > 1000000 {
5847 return xerrors.Errorf("Value in field \"name\" was too long")
5848 }
5849
5850 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5851 return err
5852 }
5853 if _, err := cw.WriteString(string("name")); err != nil {
5854 return err
5855 }
5856
5857 if len(t.Name) > 1000000 {
5858 return xerrors.Errorf("Value in field t.Name was too long")
5859 }
5860
5861 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5862 return err
5863 }
5864 if _, err := cw.WriteString(string(t.Name)); err != nil {
5865 return err
5866 }
5867
5868 // t.LexiconTypeID (string) (string)
5869 if len("$type") > 1000000 {
5870 return xerrors.Errorf("Value in field \"$type\" was too long")
5871 }
5872
5873 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5874 return err
5875 }
5876 if _, err := cw.WriteString(string("$type")); err != nil {
5877 return err
5878 }
5879
5880 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil {
5881 return err
5882 }
5883 if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil {
5884 return err
5885 }
5886
5887 // t.Labels ([]string) (slice)
5888 if t.Labels != nil {
5889
5890 if len("labels") > 1000000 {
5891 return xerrors.Errorf("Value in field \"labels\" was too long")
5892 }
5893
5894 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("labels"))); err != nil {
5895 return err
5896 }
5897 if _, err := cw.WriteString(string("labels")); err != nil {
5898 return err
5899 }
5900
5901 if len(t.Labels) > 8192 {
5902 return xerrors.Errorf("Slice value in field t.Labels was too long")
5903 }
5904
5905 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Labels))); err != nil {
5906 return err
5907 }
5908 for _, v := range t.Labels {
5909 if len(v) > 1000000 {
5910 return xerrors.Errorf("Value in field v was too long")
5911 }
5912
5913 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
5914 return err
5915 }
5916 if _, err := cw.WriteString(string(v)); err != nil {
5917 return err
5918 }
5919
5920 }
5921 }
5922
5923 // t.Source (string) (string)
5924 if t.Source != nil {
5925
5926 if len("source") > 1000000 {
5927 return xerrors.Errorf("Value in field \"source\" was too long")
5928 }
5929
5930 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
5931 return err
5932 }
5933 if _, err := cw.WriteString(string("source")); err != nil {
5934 return err
5935 }
5936
5937 if t.Source == nil {
5938 if _, err := cw.Write(cbg.CborNull); err != nil {
5939 return err
5940 }
5941 } else {
5942 if len(*t.Source) > 1000000 {
5943 return xerrors.Errorf("Value in field t.Source was too long")
5944 }
5945
5946 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil {
5947 return err
5948 }
5949 if _, err := cw.WriteString(string(*t.Source)); err != nil {
5950 return err
5951 }
5952 }
5953 }
5954
5955 // t.Spindle (string) (string)
5956 if t.Spindle != nil {
5957
5958 if len("spindle") > 1000000 {
5959 return xerrors.Errorf("Value in field \"spindle\" was too long")
5960 }
5961
5962 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("spindle"))); err != nil {
5963 return err
5964 }
5965 if _, err := cw.WriteString(string("spindle")); err != nil {
5966 return err
5967 }
5968
5969 if t.Spindle == nil {
5970 if _, err := cw.Write(cbg.CborNull); err != nil {
5971 return err
5972 }
5973 } else {
5974 if len(*t.Spindle) > 1000000 {
5975 return xerrors.Errorf("Value in field t.Spindle was too long")
5976 }
5977
5978 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Spindle))); err != nil {
5979 return err
5980 }
5981 if _, err := cw.WriteString(string(*t.Spindle)); err != nil {
5982 return err
5983 }
5984 }
5985 }
5986
5987 // t.CreatedAt (string) (string)
5988 if len("createdAt") > 1000000 {
5989 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5990 }
5991
5992 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5993 return err
5994 }
5995 if _, err := cw.WriteString(string("createdAt")); err != nil {
5996 return err
5997 }
5998
5999 if len(t.CreatedAt) > 1000000 {
6000 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6001 }
6002
6003 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6004 return err
6005 }
6006 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6007 return err
6008 }
6009
6010 // t.Description (string) (string)
6011 if t.Description != nil {
6012
6013 if len("description") > 1000000 {
6014 return xerrors.Errorf("Value in field \"description\" was too long")
6015 }
6016
6017 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
6018 return err
6019 }
6020 if _, err := cw.WriteString(string("description")); err != nil {
6021 return err
6022 }
6023
6024 if t.Description == nil {
6025 if _, err := cw.Write(cbg.CborNull); err != nil {
6026 return err
6027 }
6028 } else {
6029 if len(*t.Description) > 1000000 {
6030 return xerrors.Errorf("Value in field t.Description was too long")
6031 }
6032
6033 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
6034 return err
6035 }
6036 if _, err := cw.WriteString(string(*t.Description)); err != nil {
6037 return err
6038 }
6039 }
6040 }
6041 return nil
6042}
6043
6044func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) {
6045 *t = Repo{}
6046
6047 cr := cbg.NewCborReader(r)
6048
6049 maj, extra, err := cr.ReadHeader()
6050 if err != nil {
6051 return err
6052 }
6053 defer func() {
6054 if err == io.EOF {
6055 err = io.ErrUnexpectedEOF
6056 }
6057 }()
6058
6059 if maj != cbg.MajMap {
6060 return fmt.Errorf("cbor input should be of type map")
6061 }
6062
6063 if extra > cbg.MaxLength {
6064 return fmt.Errorf("Repo: map struct too large (%d)", extra)
6065 }
6066
6067 n := extra
6068
6069 nameBuf := make([]byte, 11)
6070 for i := uint64(0); i < n; i++ {
6071 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6072 if err != nil {
6073 return err
6074 }
6075
6076 if !ok {
6077 // Field doesn't exist on this type, so ignore it
6078 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6079 return err
6080 }
6081 continue
6082 }
6083
6084 switch string(nameBuf[:nameLen]) {
6085 // t.Knot (string) (string)
6086 case "knot":
6087
6088 {
6089 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6090 if err != nil {
6091 return err
6092 }
6093
6094 t.Knot = string(sval)
6095 }
6096 // t.Name (string) (string)
6097 case "name":
6098
6099 {
6100 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6101 if err != nil {
6102 return err
6103 }
6104
6105 t.Name = string(sval)
6106 }
6107 // t.LexiconTypeID (string) (string)
6108 case "$type":
6109
6110 {
6111 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6112 if err != nil {
6113 return err
6114 }
6115
6116 t.LexiconTypeID = string(sval)
6117 }
6118 // t.Labels ([]string) (slice)
6119 case "labels":
6120
6121 maj, extra, err = cr.ReadHeader()
6122 if err != nil {
6123 return err
6124 }
6125
6126 if extra > 8192 {
6127 return fmt.Errorf("t.Labels: array too large (%d)", extra)
6128 }
6129
6130 if maj != cbg.MajArray {
6131 return fmt.Errorf("expected cbor array")
6132 }
6133
6134 if extra > 0 {
6135 t.Labels = make([]string, extra)
6136 }
6137
6138 for i := 0; i < int(extra); i++ {
6139 {
6140 var maj byte
6141 var extra uint64
6142 var err error
6143 _ = maj
6144 _ = extra
6145 _ = err
6146
6147 {
6148 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6149 if err != nil {
6150 return err
6151 }
6152
6153 t.Labels[i] = string(sval)
6154 }
6155
6156 }
6157 }
6158 // t.Source (string) (string)
6159 case "source":
6160
6161 {
6162 b, err := cr.ReadByte()
6163 if err != nil {
6164 return err
6165 }
6166 if b != cbg.CborNull[0] {
6167 if err := cr.UnreadByte(); err != nil {
6168 return err
6169 }
6170
6171 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6172 if err != nil {
6173 return err
6174 }
6175
6176 t.Source = (*string)(&sval)
6177 }
6178 }
6179 // t.Spindle (string) (string)
6180 case "spindle":
6181
6182 {
6183 b, err := cr.ReadByte()
6184 if err != nil {
6185 return err
6186 }
6187 if b != cbg.CborNull[0] {
6188 if err := cr.UnreadByte(); err != nil {
6189 return err
6190 }
6191
6192 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6193 if err != nil {
6194 return err
6195 }
6196
6197 t.Spindle = (*string)(&sval)
6198 }
6199 }
6200 // t.CreatedAt (string) (string)
6201 case "createdAt":
6202
6203 {
6204 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6205 if err != nil {
6206 return err
6207 }
6208
6209 t.CreatedAt = string(sval)
6210 }
6211 // t.Description (string) (string)
6212 case "description":
6213
6214 {
6215 b, err := cr.ReadByte()
6216 if err != nil {
6217 return err
6218 }
6219 if b != cbg.CborNull[0] {
6220 if err := cr.UnreadByte(); err != nil {
6221 return err
6222 }
6223
6224 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6225 if err != nil {
6226 return err
6227 }
6228
6229 t.Description = (*string)(&sval)
6230 }
6231 }
6232
6233 default:
6234 // Field doesn't exist on this type, so ignore it
6235 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6236 return err
6237 }
6238 }
6239 }
6240
6241 return nil
6242}
6243func (t *RepoArtifact) MarshalCBOR(w io.Writer) error {
6244 if t == nil {
6245 _, err := w.Write(cbg.CborNull)
6246 return err
6247 }
6248
6249 cw := cbg.NewCborWriter(w)
6250 fieldCount := 6
6251
6252 if t.Tag == nil {
6253 fieldCount--
6254 }
6255
6256 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6257 return err
6258 }
6259
6260 // t.Tag (util.LexBytes) (slice)
6261 if t.Tag != nil {
6262
6263 if len("tag") > 1000000 {
6264 return xerrors.Errorf("Value in field \"tag\" was too long")
6265 }
6266
6267 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tag"))); err != nil {
6268 return err
6269 }
6270 if _, err := cw.WriteString(string("tag")); err != nil {
6271 return err
6272 }
6273
6274 if len(t.Tag) > 2097152 {
6275 return xerrors.Errorf("Byte array in field t.Tag was too long")
6276 }
6277
6278 if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Tag))); err != nil {
6279 return err
6280 }
6281
6282 if _, err := cw.Write(t.Tag); err != nil {
6283 return err
6284 }
6285
6286 }
6287
6288 // t.Name (string) (string)
6289 if len("name") > 1000000 {
6290 return xerrors.Errorf("Value in field \"name\" was too long")
6291 }
6292
6293 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
6294 return err
6295 }
6296 if _, err := cw.WriteString(string("name")); err != nil {
6297 return err
6298 }
6299
6300 if len(t.Name) > 1000000 {
6301 return xerrors.Errorf("Value in field t.Name was too long")
6302 }
6303
6304 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
6305 return err
6306 }
6307 if _, err := cw.WriteString(string(t.Name)); err != nil {
6308 return err
6309 }
6310
6311 // t.Repo (string) (string)
6312 if len("repo") > 1000000 {
6313 return xerrors.Errorf("Value in field \"repo\" was too long")
6314 }
6315
6316 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6317 return err
6318 }
6319 if _, err := cw.WriteString(string("repo")); err != nil {
6320 return err
6321 }
6322
6323 if len(t.Repo) > 1000000 {
6324 return xerrors.Errorf("Value in field t.Repo was too long")
6325 }
6326
6327 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
6328 return err
6329 }
6330 if _, err := cw.WriteString(string(t.Repo)); err != nil {
6331 return err
6332 }
6333
6334 // t.LexiconTypeID (string) (string)
6335 if len("$type") > 1000000 {
6336 return xerrors.Errorf("Value in field \"$type\" was too long")
6337 }
6338
6339 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6340 return err
6341 }
6342 if _, err := cw.WriteString(string("$type")); err != nil {
6343 return err
6344 }
6345
6346 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.artifact"))); err != nil {
6347 return err
6348 }
6349 if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil {
6350 return err
6351 }
6352
6353 // t.Artifact (util.LexBlob) (struct)
6354 if len("artifact") > 1000000 {
6355 return xerrors.Errorf("Value in field \"artifact\" was too long")
6356 }
6357
6358 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("artifact"))); err != nil {
6359 return err
6360 }
6361 if _, err := cw.WriteString(string("artifact")); err != nil {
6362 return err
6363 }
6364
6365 if err := t.Artifact.MarshalCBOR(cw); err != nil {
6366 return err
6367 }
6368
6369 // t.CreatedAt (string) (string)
6370 if len("createdAt") > 1000000 {
6371 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6372 }
6373
6374 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6375 return err
6376 }
6377 if _, err := cw.WriteString(string("createdAt")); err != nil {
6378 return err
6379 }
6380
6381 if len(t.CreatedAt) > 1000000 {
6382 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6383 }
6384
6385 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6386 return err
6387 }
6388 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6389 return err
6390 }
6391 return nil
6392}
6393
6394func (t *RepoArtifact) UnmarshalCBOR(r io.Reader) (err error) {
6395 *t = RepoArtifact{}
6396
6397 cr := cbg.NewCborReader(r)
6398
6399 maj, extra, err := cr.ReadHeader()
6400 if err != nil {
6401 return err
6402 }
6403 defer func() {
6404 if err == io.EOF {
6405 err = io.ErrUnexpectedEOF
6406 }
6407 }()
6408
6409 if maj != cbg.MajMap {
6410 return fmt.Errorf("cbor input should be of type map")
6411 }
6412
6413 if extra > cbg.MaxLength {
6414 return fmt.Errorf("RepoArtifact: map struct too large (%d)", extra)
6415 }
6416
6417 n := extra
6418
6419 nameBuf := make([]byte, 9)
6420 for i := uint64(0); i < n; i++ {
6421 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6422 if err != nil {
6423 return err
6424 }
6425
6426 if !ok {
6427 // Field doesn't exist on this type, so ignore it
6428 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6429 return err
6430 }
6431 continue
6432 }
6433
6434 switch string(nameBuf[:nameLen]) {
6435 // t.Tag (util.LexBytes) (slice)
6436 case "tag":
6437
6438 maj, extra, err = cr.ReadHeader()
6439 if err != nil {
6440 return err
6441 }
6442
6443 if extra > 2097152 {
6444 return fmt.Errorf("t.Tag: byte array too large (%d)", extra)
6445 }
6446 if maj != cbg.MajByteString {
6447 return fmt.Errorf("expected byte array")
6448 }
6449
6450 if extra > 0 {
6451 t.Tag = make([]uint8, extra)
6452 }
6453
6454 if _, err := io.ReadFull(cr, t.Tag); err != nil {
6455 return err
6456 }
6457
6458 // t.Name (string) (string)
6459 case "name":
6460
6461 {
6462 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6463 if err != nil {
6464 return err
6465 }
6466
6467 t.Name = string(sval)
6468 }
6469 // t.Repo (string) (string)
6470 case "repo":
6471
6472 {
6473 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6474 if err != nil {
6475 return err
6476 }
6477
6478 t.Repo = string(sval)
6479 }
6480 // t.LexiconTypeID (string) (string)
6481 case "$type":
6482
6483 {
6484 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6485 if err != nil {
6486 return err
6487 }
6488
6489 t.LexiconTypeID = string(sval)
6490 }
6491 // t.Artifact (util.LexBlob) (struct)
6492 case "artifact":
6493
6494 {
6495
6496 b, err := cr.ReadByte()
6497 if err != nil {
6498 return err
6499 }
6500 if b != cbg.CborNull[0] {
6501 if err := cr.UnreadByte(); err != nil {
6502 return err
6503 }
6504 t.Artifact = new(util.LexBlob)
6505 if err := t.Artifact.UnmarshalCBOR(cr); err != nil {
6506 return xerrors.Errorf("unmarshaling t.Artifact pointer: %w", err)
6507 }
6508 }
6509
6510 }
6511 // t.CreatedAt (string) (string)
6512 case "createdAt":
6513
6514 {
6515 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6516 if err != nil {
6517 return err
6518 }
6519
6520 t.CreatedAt = string(sval)
6521 }
6522
6523 default:
6524 // Field doesn't exist on this type, so ignore it
6525 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6526 return err
6527 }
6528 }
6529 }
6530
6531 return nil
6532}
6533func (t *RepoCollaborator) MarshalCBOR(w io.Writer) error {
6534 if t == nil {
6535 _, err := w.Write(cbg.CborNull)
6536 return err
6537 }
6538
6539 cw := cbg.NewCborWriter(w)
6540
6541 if _, err := cw.Write([]byte{164}); err != nil {
6542 return err
6543 }
6544
6545 // t.Repo (string) (string)
6546 if len("repo") > 1000000 {
6547 return xerrors.Errorf("Value in field \"repo\" was too long")
6548 }
6549
6550 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6551 return err
6552 }
6553 if _, err := cw.WriteString(string("repo")); err != nil {
6554 return err
6555 }
6556
6557 if len(t.Repo) > 1000000 {
6558 return xerrors.Errorf("Value in field t.Repo was too long")
6559 }
6560
6561 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
6562 return err
6563 }
6564 if _, err := cw.WriteString(string(t.Repo)); err != nil {
6565 return err
6566 }
6567
6568 // t.LexiconTypeID (string) (string)
6569 if len("$type") > 1000000 {
6570 return xerrors.Errorf("Value in field \"$type\" was too long")
6571 }
6572
6573 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6574 return err
6575 }
6576 if _, err := cw.WriteString(string("$type")); err != nil {
6577 return err
6578 }
6579
6580 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.collaborator"))); err != nil {
6581 return err
6582 }
6583 if _, err := cw.WriteString(string("sh.tangled.repo.collaborator")); err != nil {
6584 return err
6585 }
6586
6587 // t.Subject (string) (string)
6588 if len("subject") > 1000000 {
6589 return xerrors.Errorf("Value in field \"subject\" was too long")
6590 }
6591
6592 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
6593 return err
6594 }
6595 if _, err := cw.WriteString(string("subject")); err != nil {
6596 return err
6597 }
6598
6599 if len(t.Subject) > 1000000 {
6600 return xerrors.Errorf("Value in field t.Subject was too long")
6601 }
6602
6603 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
6604 return err
6605 }
6606 if _, err := cw.WriteString(string(t.Subject)); err != nil {
6607 return err
6608 }
6609
6610 // t.CreatedAt (string) (string)
6611 if len("createdAt") > 1000000 {
6612 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6613 }
6614
6615 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6616 return err
6617 }
6618 if _, err := cw.WriteString(string("createdAt")); err != nil {
6619 return err
6620 }
6621
6622 if len(t.CreatedAt) > 1000000 {
6623 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6624 }
6625
6626 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6627 return err
6628 }
6629 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6630 return err
6631 }
6632 return nil
6633}
6634
6635func (t *RepoCollaborator) UnmarshalCBOR(r io.Reader) (err error) {
6636 *t = RepoCollaborator{}
6637
6638 cr := cbg.NewCborReader(r)
6639
6640 maj, extra, err := cr.ReadHeader()
6641 if err != nil {
6642 return err
6643 }
6644 defer func() {
6645 if err == io.EOF {
6646 err = io.ErrUnexpectedEOF
6647 }
6648 }()
6649
6650 if maj != cbg.MajMap {
6651 return fmt.Errorf("cbor input should be of type map")
6652 }
6653
6654 if extra > cbg.MaxLength {
6655 return fmt.Errorf("RepoCollaborator: map struct too large (%d)", extra)
6656 }
6657
6658 n := extra
6659
6660 nameBuf := make([]byte, 9)
6661 for i := uint64(0); i < n; i++ {
6662 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6663 if err != nil {
6664 return err
6665 }
6666
6667 if !ok {
6668 // Field doesn't exist on this type, so ignore it
6669 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6670 return err
6671 }
6672 continue
6673 }
6674
6675 switch string(nameBuf[:nameLen]) {
6676 // t.Repo (string) (string)
6677 case "repo":
6678
6679 {
6680 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6681 if err != nil {
6682 return err
6683 }
6684
6685 t.Repo = string(sval)
6686 }
6687 // t.LexiconTypeID (string) (string)
6688 case "$type":
6689
6690 {
6691 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6692 if err != nil {
6693 return err
6694 }
6695
6696 t.LexiconTypeID = string(sval)
6697 }
6698 // t.Subject (string) (string)
6699 case "subject":
6700
6701 {
6702 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6703 if err != nil {
6704 return err
6705 }
6706
6707 t.Subject = string(sval)
6708 }
6709 // t.CreatedAt (string) (string)
6710 case "createdAt":
6711
6712 {
6713 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6714 if err != nil {
6715 return err
6716 }
6717
6718 t.CreatedAt = string(sval)
6719 }
6720
6721 default:
6722 // Field doesn't exist on this type, so ignore it
6723 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6724 return err
6725 }
6726 }
6727 }
6728
6729 return nil
6730}
6731func (t *RepoIssue) MarshalCBOR(w io.Writer) error {
6732 if t == nil {
6733 _, err := w.Write(cbg.CborNull)
6734 return err
6735 }
6736
6737 cw := cbg.NewCborWriter(w)
6738 fieldCount := 5
6739
6740 if t.Body == nil {
6741 fieldCount--
6742 }
6743
6744 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6745 return err
6746 }
6747
6748 // t.Body (string) (string)
6749 if t.Body != nil {
6750
6751 if len("body") > 1000000 {
6752 return xerrors.Errorf("Value in field \"body\" was too long")
6753 }
6754
6755 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
6756 return err
6757 }
6758 if _, err := cw.WriteString(string("body")); err != nil {
6759 return err
6760 }
6761
6762 if t.Body == nil {
6763 if _, err := cw.Write(cbg.CborNull); err != nil {
6764 return err
6765 }
6766 } else {
6767 if len(*t.Body) > 1000000 {
6768 return xerrors.Errorf("Value in field t.Body was too long")
6769 }
6770
6771 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
6772 return err
6773 }
6774 if _, err := cw.WriteString(string(*t.Body)); err != nil {
6775 return err
6776 }
6777 }
6778 }
6779
6780 // t.Repo (string) (string)
6781 if len("repo") > 1000000 {
6782 return xerrors.Errorf("Value in field \"repo\" was too long")
6783 }
6784
6785 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6786 return err
6787 }
6788 if _, err := cw.WriteString(string("repo")); err != nil {
6789 return err
6790 }
6791
6792 if len(t.Repo) > 1000000 {
6793 return xerrors.Errorf("Value in field t.Repo was too long")
6794 }
6795
6796 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
6797 return err
6798 }
6799 if _, err := cw.WriteString(string(t.Repo)); err != nil {
6800 return err
6801 }
6802
6803 // t.LexiconTypeID (string) (string)
6804 if len("$type") > 1000000 {
6805 return xerrors.Errorf("Value in field \"$type\" was too long")
6806 }
6807
6808 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6809 return err
6810 }
6811 if _, err := cw.WriteString(string("$type")); err != nil {
6812 return err
6813 }
6814
6815 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil {
6816 return err
6817 }
6818 if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil {
6819 return err
6820 }
6821
6822 // t.Title (string) (string)
6823 if len("title") > 1000000 {
6824 return xerrors.Errorf("Value in field \"title\" was too long")
6825 }
6826
6827 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
6828 return err
6829 }
6830 if _, err := cw.WriteString(string("title")); err != nil {
6831 return err
6832 }
6833
6834 if len(t.Title) > 1000000 {
6835 return xerrors.Errorf("Value in field t.Title was too long")
6836 }
6837
6838 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
6839 return err
6840 }
6841 if _, err := cw.WriteString(string(t.Title)); err != nil {
6842 return err
6843 }
6844
6845 // t.CreatedAt (string) (string)
6846 if len("createdAt") > 1000000 {
6847 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6848 }
6849
6850 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6851 return err
6852 }
6853 if _, err := cw.WriteString(string("createdAt")); err != nil {
6854 return err
6855 }
6856
6857 if len(t.CreatedAt) > 1000000 {
6858 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6859 }
6860
6861 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6862 return err
6863 }
6864 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6865 return err
6866 }
6867 return nil
6868}
6869
6870func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) {
6871 *t = RepoIssue{}
6872
6873 cr := cbg.NewCborReader(r)
6874
6875 maj, extra, err := cr.ReadHeader()
6876 if err != nil {
6877 return err
6878 }
6879 defer func() {
6880 if err == io.EOF {
6881 err = io.ErrUnexpectedEOF
6882 }
6883 }()
6884
6885 if maj != cbg.MajMap {
6886 return fmt.Errorf("cbor input should be of type map")
6887 }
6888
6889 if extra > cbg.MaxLength {
6890 return fmt.Errorf("RepoIssue: map struct too large (%d)", extra)
6891 }
6892
6893 n := extra
6894
6895 nameBuf := make([]byte, 9)
6896 for i := uint64(0); i < n; i++ {
6897 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6898 if err != nil {
6899 return err
6900 }
6901
6902 if !ok {
6903 // Field doesn't exist on this type, so ignore it
6904 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6905 return err
6906 }
6907 continue
6908 }
6909
6910 switch string(nameBuf[:nameLen]) {
6911 // t.Body (string) (string)
6912 case "body":
6913
6914 {
6915 b, err := cr.ReadByte()
6916 if err != nil {
6917 return err
6918 }
6919 if b != cbg.CborNull[0] {
6920 if err := cr.UnreadByte(); err != nil {
6921 return err
6922 }
6923
6924 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6925 if err != nil {
6926 return err
6927 }
6928
6929 t.Body = (*string)(&sval)
6930 }
6931 }
6932 // t.Repo (string) (string)
6933 case "repo":
6934
6935 {
6936 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6937 if err != nil {
6938 return err
6939 }
6940
6941 t.Repo = string(sval)
6942 }
6943 // t.LexiconTypeID (string) (string)
6944 case "$type":
6945
6946 {
6947 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6948 if err != nil {
6949 return err
6950 }
6951
6952 t.LexiconTypeID = string(sval)
6953 }
6954 // t.Title (string) (string)
6955 case "title":
6956
6957 {
6958 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6959 if err != nil {
6960 return err
6961 }
6962
6963 t.Title = string(sval)
6964 }
6965 // t.CreatedAt (string) (string)
6966 case "createdAt":
6967
6968 {
6969 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6970 if err != nil {
6971 return err
6972 }
6973
6974 t.CreatedAt = string(sval)
6975 }
6976
6977 default:
6978 // Field doesn't exist on this type, so ignore it
6979 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6980 return err
6981 }
6982 }
6983 }
6984
6985 return nil
6986}
6987func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error {
6988 if t == nil {
6989 _, err := w.Write(cbg.CborNull)
6990 return err
6991 }
6992
6993 cw := cbg.NewCborWriter(w)
6994 fieldCount := 5
6995
6996 if t.ReplyTo == nil {
6997 fieldCount--
6998 }
6999
7000 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7001 return err
7002 }
7003
7004 // t.Body (string) (string)
7005 if len("body") > 1000000 {
7006 return xerrors.Errorf("Value in field \"body\" was too long")
7007 }
7008
7009 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
7010 return err
7011 }
7012 if _, err := cw.WriteString(string("body")); err != nil {
7013 return err
7014 }
7015
7016 if len(t.Body) > 1000000 {
7017 return xerrors.Errorf("Value in field t.Body was too long")
7018 }
7019
7020 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
7021 return err
7022 }
7023 if _, err := cw.WriteString(string(t.Body)); err != nil {
7024 return err
7025 }
7026
7027 // t.LexiconTypeID (string) (string)
7028 if len("$type") > 1000000 {
7029 return xerrors.Errorf("Value in field \"$type\" was too long")
7030 }
7031
7032 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7033 return err
7034 }
7035 if _, err := cw.WriteString(string("$type")); err != nil {
7036 return err
7037 }
7038
7039 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil {
7040 return err
7041 }
7042 if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil {
7043 return err
7044 }
7045
7046 // t.Issue (string) (string)
7047 if len("issue") > 1000000 {
7048 return xerrors.Errorf("Value in field \"issue\" was too long")
7049 }
7050
7051 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
7052 return err
7053 }
7054 if _, err := cw.WriteString(string("issue")); err != nil {
7055 return err
7056 }
7057
7058 if len(t.Issue) > 1000000 {
7059 return xerrors.Errorf("Value in field t.Issue was too long")
7060 }
7061
7062 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
7063 return err
7064 }
7065 if _, err := cw.WriteString(string(t.Issue)); err != nil {
7066 return err
7067 }
7068
7069 // t.ReplyTo (string) (string)
7070 if t.ReplyTo != nil {
7071
7072 if len("replyTo") > 1000000 {
7073 return xerrors.Errorf("Value in field \"replyTo\" was too long")
7074 }
7075
7076 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("replyTo"))); err != nil {
7077 return err
7078 }
7079 if _, err := cw.WriteString(string("replyTo")); err != nil {
7080 return err
7081 }
7082
7083 if t.ReplyTo == nil {
7084 if _, err := cw.Write(cbg.CborNull); err != nil {
7085 return err
7086 }
7087 } else {
7088 if len(*t.ReplyTo) > 1000000 {
7089 return xerrors.Errorf("Value in field t.ReplyTo was too long")
7090 }
7091
7092 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ReplyTo))); err != nil {
7093 return err
7094 }
7095 if _, err := cw.WriteString(string(*t.ReplyTo)); err != nil {
7096 return err
7097 }
7098 }
7099 }
7100
7101 // t.CreatedAt (string) (string)
7102 if len("createdAt") > 1000000 {
7103 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7104 }
7105
7106 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7107 return err
7108 }
7109 if _, err := cw.WriteString(string("createdAt")); err != nil {
7110 return err
7111 }
7112
7113 if len(t.CreatedAt) > 1000000 {
7114 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7115 }
7116
7117 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7118 return err
7119 }
7120 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7121 return err
7122 }
7123 return nil
7124}
7125
7126func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) {
7127 *t = RepoIssueComment{}
7128
7129 cr := cbg.NewCborReader(r)
7130
7131 maj, extra, err := cr.ReadHeader()
7132 if err != nil {
7133 return err
7134 }
7135 defer func() {
7136 if err == io.EOF {
7137 err = io.ErrUnexpectedEOF
7138 }
7139 }()
7140
7141 if maj != cbg.MajMap {
7142 return fmt.Errorf("cbor input should be of type map")
7143 }
7144
7145 if extra > cbg.MaxLength {
7146 return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra)
7147 }
7148
7149 n := extra
7150
7151 nameBuf := make([]byte, 9)
7152 for i := uint64(0); i < n; i++ {
7153 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7154 if err != nil {
7155 return err
7156 }
7157
7158 if !ok {
7159 // Field doesn't exist on this type, so ignore it
7160 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7161 return err
7162 }
7163 continue
7164 }
7165
7166 switch string(nameBuf[:nameLen]) {
7167 // t.Body (string) (string)
7168 case "body":
7169
7170 {
7171 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7172 if err != nil {
7173 return err
7174 }
7175
7176 t.Body = string(sval)
7177 }
7178 // t.LexiconTypeID (string) (string)
7179 case "$type":
7180
7181 {
7182 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7183 if err != nil {
7184 return err
7185 }
7186
7187 t.LexiconTypeID = string(sval)
7188 }
7189 // t.Issue (string) (string)
7190 case "issue":
7191
7192 {
7193 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7194 if err != nil {
7195 return err
7196 }
7197
7198 t.Issue = string(sval)
7199 }
7200 // t.ReplyTo (string) (string)
7201 case "replyTo":
7202
7203 {
7204 b, err := cr.ReadByte()
7205 if err != nil {
7206 return err
7207 }
7208 if b != cbg.CborNull[0] {
7209 if err := cr.UnreadByte(); err != nil {
7210 return err
7211 }
7212
7213 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7214 if err != nil {
7215 return err
7216 }
7217
7218 t.ReplyTo = (*string)(&sval)
7219 }
7220 }
7221 // t.CreatedAt (string) (string)
7222 case "createdAt":
7223
7224 {
7225 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7226 if err != nil {
7227 return err
7228 }
7229
7230 t.CreatedAt = string(sval)
7231 }
7232
7233 default:
7234 // Field doesn't exist on this type, so ignore it
7235 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7236 return err
7237 }
7238 }
7239 }
7240
7241 return nil
7242}
7243func (t *RepoIssueState) MarshalCBOR(w io.Writer) error {
7244 if t == nil {
7245 _, err := w.Write(cbg.CborNull)
7246 return err
7247 }
7248
7249 cw := cbg.NewCborWriter(w)
7250
7251 if _, err := cw.Write([]byte{163}); err != nil {
7252 return err
7253 }
7254
7255 // t.LexiconTypeID (string) (string)
7256 if len("$type") > 1000000 {
7257 return xerrors.Errorf("Value in field \"$type\" was too long")
7258 }
7259
7260 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7261 return err
7262 }
7263 if _, err := cw.WriteString(string("$type")); err != nil {
7264 return err
7265 }
7266
7267 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil {
7268 return err
7269 }
7270 if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil {
7271 return err
7272 }
7273
7274 // t.Issue (string) (string)
7275 if len("issue") > 1000000 {
7276 return xerrors.Errorf("Value in field \"issue\" was too long")
7277 }
7278
7279 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
7280 return err
7281 }
7282 if _, err := cw.WriteString(string("issue")); err != nil {
7283 return err
7284 }
7285
7286 if len(t.Issue) > 1000000 {
7287 return xerrors.Errorf("Value in field t.Issue was too long")
7288 }
7289
7290 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
7291 return err
7292 }
7293 if _, err := cw.WriteString(string(t.Issue)); err != nil {
7294 return err
7295 }
7296
7297 // t.State (string) (string)
7298 if len("state") > 1000000 {
7299 return xerrors.Errorf("Value in field \"state\" was too long")
7300 }
7301
7302 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil {
7303 return err
7304 }
7305 if _, err := cw.WriteString(string("state")); err != nil {
7306 return err
7307 }
7308
7309 if len(t.State) > 1000000 {
7310 return xerrors.Errorf("Value in field t.State was too long")
7311 }
7312
7313 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil {
7314 return err
7315 }
7316 if _, err := cw.WriteString(string(t.State)); err != nil {
7317 return err
7318 }
7319 return nil
7320}
7321
7322func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) {
7323 *t = RepoIssueState{}
7324
7325 cr := cbg.NewCborReader(r)
7326
7327 maj, extra, err := cr.ReadHeader()
7328 if err != nil {
7329 return err
7330 }
7331 defer func() {
7332 if err == io.EOF {
7333 err = io.ErrUnexpectedEOF
7334 }
7335 }()
7336
7337 if maj != cbg.MajMap {
7338 return fmt.Errorf("cbor input should be of type map")
7339 }
7340
7341 if extra > cbg.MaxLength {
7342 return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra)
7343 }
7344
7345 n := extra
7346
7347 nameBuf := make([]byte, 5)
7348 for i := uint64(0); i < n; i++ {
7349 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7350 if err != nil {
7351 return err
7352 }
7353
7354 if !ok {
7355 // Field doesn't exist on this type, so ignore it
7356 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7357 return err
7358 }
7359 continue
7360 }
7361
7362 switch string(nameBuf[:nameLen]) {
7363 // t.LexiconTypeID (string) (string)
7364 case "$type":
7365
7366 {
7367 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7368 if err != nil {
7369 return err
7370 }
7371
7372 t.LexiconTypeID = string(sval)
7373 }
7374 // t.Issue (string) (string)
7375 case "issue":
7376
7377 {
7378 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7379 if err != nil {
7380 return err
7381 }
7382
7383 t.Issue = string(sval)
7384 }
7385 // t.State (string) (string)
7386 case "state":
7387
7388 {
7389 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7390 if err != nil {
7391 return err
7392 }
7393
7394 t.State = string(sval)
7395 }
7396
7397 default:
7398 // Field doesn't exist on this type, so ignore it
7399 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7400 return err
7401 }
7402 }
7403 }
7404
7405 return nil
7406}
7407func (t *RepoPull) MarshalCBOR(w io.Writer) error {
7408 if t == nil {
7409 _, err := w.Write(cbg.CborNull)
7410 return err
7411 }
7412
7413 cw := cbg.NewCborWriter(w)
7414 fieldCount := 7
7415
7416 if t.Body == nil {
7417 fieldCount--
7418 }
7419
7420 if t.Source == nil {
7421 fieldCount--
7422 }
7423
7424 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7425 return err
7426 }
7427
7428 // t.Body (string) (string)
7429 if t.Body != nil {
7430
7431 if len("body") > 1000000 {
7432 return xerrors.Errorf("Value in field \"body\" was too long")
7433 }
7434
7435 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
7436 return err
7437 }
7438 if _, err := cw.WriteString(string("body")); err != nil {
7439 return err
7440 }
7441
7442 if t.Body == nil {
7443 if _, err := cw.Write(cbg.CborNull); err != nil {
7444 return err
7445 }
7446 } else {
7447 if len(*t.Body) > 1000000 {
7448 return xerrors.Errorf("Value in field t.Body was too long")
7449 }
7450
7451 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
7452 return err
7453 }
7454 if _, err := cw.WriteString(string(*t.Body)); err != nil {
7455 return err
7456 }
7457 }
7458 }
7459
7460 // t.LexiconTypeID (string) (string)
7461 if len("$type") > 1000000 {
7462 return xerrors.Errorf("Value in field \"$type\" was too long")
7463 }
7464
7465 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7466 return err
7467 }
7468 if _, err := cw.WriteString(string("$type")); err != nil {
7469 return err
7470 }
7471
7472 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil {
7473 return err
7474 }
7475 if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil {
7476 return err
7477 }
7478
7479 // t.Patch (string) (string)
7480 if len("patch") > 1000000 {
7481 return xerrors.Errorf("Value in field \"patch\" was too long")
7482 }
7483
7484 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil {
7485 return err
7486 }
7487 if _, err := cw.WriteString(string("patch")); err != nil {
7488 return err
7489 }
7490
7491 if len(t.Patch) > 1000000 {
7492 return xerrors.Errorf("Value in field t.Patch was too long")
7493 }
7494
7495 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Patch))); err != nil {
7496 return err
7497 }
7498 if _, err := cw.WriteString(string(t.Patch)); err != nil {
7499 return err
7500 }
7501
7502 // t.Title (string) (string)
7503 if len("title") > 1000000 {
7504 return xerrors.Errorf("Value in field \"title\" was too long")
7505 }
7506
7507 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
7508 return err
7509 }
7510 if _, err := cw.WriteString(string("title")); err != nil {
7511 return err
7512 }
7513
7514 if len(t.Title) > 1000000 {
7515 return xerrors.Errorf("Value in field t.Title was too long")
7516 }
7517
7518 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
7519 return err
7520 }
7521 if _, err := cw.WriteString(string(t.Title)); err != nil {
7522 return err
7523 }
7524
7525 // t.Source (tangled.RepoPull_Source) (struct)
7526 if t.Source != nil {
7527
7528 if len("source") > 1000000 {
7529 return xerrors.Errorf("Value in field \"source\" was too long")
7530 }
7531
7532 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
7533 return err
7534 }
7535 if _, err := cw.WriteString(string("source")); err != nil {
7536 return err
7537 }
7538
7539 if err := t.Source.MarshalCBOR(cw); err != nil {
7540 return err
7541 }
7542 }
7543
7544 // t.Target (tangled.RepoPull_Target) (struct)
7545 if len("target") > 1000000 {
7546 return xerrors.Errorf("Value in field \"target\" was too long")
7547 }
7548
7549 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("target"))); err != nil {
7550 return err
7551 }
7552 if _, err := cw.WriteString(string("target")); err != nil {
7553 return err
7554 }
7555
7556 if err := t.Target.MarshalCBOR(cw); err != nil {
7557 return err
7558 }
7559
7560 // t.CreatedAt (string) (string)
7561 if len("createdAt") > 1000000 {
7562 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7563 }
7564
7565 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7566 return err
7567 }
7568 if _, err := cw.WriteString(string("createdAt")); err != nil {
7569 return err
7570 }
7571
7572 if len(t.CreatedAt) > 1000000 {
7573 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7574 }
7575
7576 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7577 return err
7578 }
7579 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7580 return err
7581 }
7582 return nil
7583}
7584
7585func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) {
7586 *t = RepoPull{}
7587
7588 cr := cbg.NewCborReader(r)
7589
7590 maj, extra, err := cr.ReadHeader()
7591 if err != nil {
7592 return err
7593 }
7594 defer func() {
7595 if err == io.EOF {
7596 err = io.ErrUnexpectedEOF
7597 }
7598 }()
7599
7600 if maj != cbg.MajMap {
7601 return fmt.Errorf("cbor input should be of type map")
7602 }
7603
7604 if extra > cbg.MaxLength {
7605 return fmt.Errorf("RepoPull: map struct too large (%d)", extra)
7606 }
7607
7608 n := extra
7609
7610 nameBuf := make([]byte, 9)
7611 for i := uint64(0); i < n; i++ {
7612 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7613 if err != nil {
7614 return err
7615 }
7616
7617 if !ok {
7618 // Field doesn't exist on this type, so ignore it
7619 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7620 return err
7621 }
7622 continue
7623 }
7624
7625 switch string(nameBuf[:nameLen]) {
7626 // t.Body (string) (string)
7627 case "body":
7628
7629 {
7630 b, err := cr.ReadByte()
7631 if err != nil {
7632 return err
7633 }
7634 if b != cbg.CborNull[0] {
7635 if err := cr.UnreadByte(); err != nil {
7636 return err
7637 }
7638
7639 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7640 if err != nil {
7641 return err
7642 }
7643
7644 t.Body = (*string)(&sval)
7645 }
7646 }
7647 // t.LexiconTypeID (string) (string)
7648 case "$type":
7649
7650 {
7651 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7652 if err != nil {
7653 return err
7654 }
7655
7656 t.LexiconTypeID = string(sval)
7657 }
7658 // t.Patch (string) (string)
7659 case "patch":
7660
7661 {
7662 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7663 if err != nil {
7664 return err
7665 }
7666
7667 t.Patch = string(sval)
7668 }
7669 // t.Title (string) (string)
7670 case "title":
7671
7672 {
7673 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7674 if err != nil {
7675 return err
7676 }
7677
7678 t.Title = string(sval)
7679 }
7680 // t.Source (tangled.RepoPull_Source) (struct)
7681 case "source":
7682
7683 {
7684
7685 b, err := cr.ReadByte()
7686 if err != nil {
7687 return err
7688 }
7689 if b != cbg.CborNull[0] {
7690 if err := cr.UnreadByte(); err != nil {
7691 return err
7692 }
7693 t.Source = new(RepoPull_Source)
7694 if err := t.Source.UnmarshalCBOR(cr); err != nil {
7695 return xerrors.Errorf("unmarshaling t.Source pointer: %w", err)
7696 }
7697 }
7698
7699 }
7700 // t.Target (tangled.RepoPull_Target) (struct)
7701 case "target":
7702
7703 {
7704
7705 b, err := cr.ReadByte()
7706 if err != nil {
7707 return err
7708 }
7709 if b != cbg.CborNull[0] {
7710 if err := cr.UnreadByte(); err != nil {
7711 return err
7712 }
7713 t.Target = new(RepoPull_Target)
7714 if err := t.Target.UnmarshalCBOR(cr); err != nil {
7715 return xerrors.Errorf("unmarshaling t.Target pointer: %w", err)
7716 }
7717 }
7718
7719 }
7720 // t.CreatedAt (string) (string)
7721 case "createdAt":
7722
7723 {
7724 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7725 if err != nil {
7726 return err
7727 }
7728
7729 t.CreatedAt = string(sval)
7730 }
7731
7732 default:
7733 // Field doesn't exist on this type, so ignore it
7734 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7735 return err
7736 }
7737 }
7738 }
7739
7740 return nil
7741}
7742func (t *RepoPullComment) MarshalCBOR(w io.Writer) error {
7743 if t == nil {
7744 _, err := w.Write(cbg.CborNull)
7745 return err
7746 }
7747
7748 cw := cbg.NewCborWriter(w)
7749
7750 if _, err := cw.Write([]byte{164}); err != nil {
7751 return err
7752 }
7753
7754 // t.Body (string) (string)
7755 if len("body") > 1000000 {
7756 return xerrors.Errorf("Value in field \"body\" was too long")
7757 }
7758
7759 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
7760 return err
7761 }
7762 if _, err := cw.WriteString(string("body")); err != nil {
7763 return err
7764 }
7765
7766 if len(t.Body) > 1000000 {
7767 return xerrors.Errorf("Value in field t.Body was too long")
7768 }
7769
7770 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
7771 return err
7772 }
7773 if _, err := cw.WriteString(string(t.Body)); err != nil {
7774 return err
7775 }
7776
7777 // t.Pull (string) (string)
7778 if len("pull") > 1000000 {
7779 return xerrors.Errorf("Value in field \"pull\" was too long")
7780 }
7781
7782 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
7783 return err
7784 }
7785 if _, err := cw.WriteString(string("pull")); err != nil {
7786 return err
7787 }
7788
7789 if len(t.Pull) > 1000000 {
7790 return xerrors.Errorf("Value in field t.Pull was too long")
7791 }
7792
7793 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
7794 return err
7795 }
7796 if _, err := cw.WriteString(string(t.Pull)); err != nil {
7797 return err
7798 }
7799
7800 // t.LexiconTypeID (string) (string)
7801 if len("$type") > 1000000 {
7802 return xerrors.Errorf("Value in field \"$type\" was too long")
7803 }
7804
7805 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7806 return err
7807 }
7808 if _, err := cw.WriteString(string("$type")); err != nil {
7809 return err
7810 }
7811
7812 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.comment"))); err != nil {
7813 return err
7814 }
7815 if _, err := cw.WriteString(string("sh.tangled.repo.pull.comment")); err != nil {
7816 return err
7817 }
7818
7819 // t.CreatedAt (string) (string)
7820 if len("createdAt") > 1000000 {
7821 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7822 }
7823
7824 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7825 return err
7826 }
7827 if _, err := cw.WriteString(string("createdAt")); err != nil {
7828 return err
7829 }
7830
7831 if len(t.CreatedAt) > 1000000 {
7832 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7833 }
7834
7835 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7836 return err
7837 }
7838 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7839 return err
7840 }
7841 return nil
7842}
7843
7844func (t *RepoPullComment) UnmarshalCBOR(r io.Reader) (err error) {
7845 *t = RepoPullComment{}
7846
7847 cr := cbg.NewCborReader(r)
7848
7849 maj, extra, err := cr.ReadHeader()
7850 if err != nil {
7851 return err
7852 }
7853 defer func() {
7854 if err == io.EOF {
7855 err = io.ErrUnexpectedEOF
7856 }
7857 }()
7858
7859 if maj != cbg.MajMap {
7860 return fmt.Errorf("cbor input should be of type map")
7861 }
7862
7863 if extra > cbg.MaxLength {
7864 return fmt.Errorf("RepoPullComment: map struct too large (%d)", extra)
7865 }
7866
7867 n := extra
7868
7869 nameBuf := make([]byte, 9)
7870 for i := uint64(0); i < n; i++ {
7871 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7872 if err != nil {
7873 return err
7874 }
7875
7876 if !ok {
7877 // Field doesn't exist on this type, so ignore it
7878 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7879 return err
7880 }
7881 continue
7882 }
7883
7884 switch string(nameBuf[:nameLen]) {
7885 // t.Body (string) (string)
7886 case "body":
7887
7888 {
7889 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7890 if err != nil {
7891 return err
7892 }
7893
7894 t.Body = string(sval)
7895 }
7896 // t.Pull (string) (string)
7897 case "pull":
7898
7899 {
7900 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7901 if err != nil {
7902 return err
7903 }
7904
7905 t.Pull = string(sval)
7906 }
7907 // t.LexiconTypeID (string) (string)
7908 case "$type":
7909
7910 {
7911 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7912 if err != nil {
7913 return err
7914 }
7915
7916 t.LexiconTypeID = string(sval)
7917 }
7918 // t.CreatedAt (string) (string)
7919 case "createdAt":
7920
7921 {
7922 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7923 if err != nil {
7924 return err
7925 }
7926
7927 t.CreatedAt = string(sval)
7928 }
7929
7930 default:
7931 // Field doesn't exist on this type, so ignore it
7932 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7933 return err
7934 }
7935 }
7936 }
7937
7938 return nil
7939}
7940func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error {
7941 if t == nil {
7942 _, err := w.Write(cbg.CborNull)
7943 return err
7944 }
7945
7946 cw := cbg.NewCborWriter(w)
7947 fieldCount := 3
7948
7949 if t.Repo == nil {
7950 fieldCount--
7951 }
7952
7953 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7954 return err
7955 }
7956
7957 // t.Sha (string) (string)
7958 if len("sha") > 1000000 {
7959 return xerrors.Errorf("Value in field \"sha\" was too long")
7960 }
7961
7962 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sha"))); err != nil {
7963 return err
7964 }
7965 if _, err := cw.WriteString(string("sha")); err != nil {
7966 return err
7967 }
7968
7969 if len(t.Sha) > 1000000 {
7970 return xerrors.Errorf("Value in field t.Sha was too long")
7971 }
7972
7973 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Sha))); err != nil {
7974 return err
7975 }
7976 if _, err := cw.WriteString(string(t.Sha)); err != nil {
7977 return err
7978 }
7979
7980 // t.Repo (string) (string)
7981 if t.Repo != nil {
7982
7983 if len("repo") > 1000000 {
7984 return xerrors.Errorf("Value in field \"repo\" was too long")
7985 }
7986
7987 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
7988 return err
7989 }
7990 if _, err := cw.WriteString(string("repo")); err != nil {
7991 return err
7992 }
7993
7994 if t.Repo == nil {
7995 if _, err := cw.Write(cbg.CborNull); err != nil {
7996 return err
7997 }
7998 } else {
7999 if len(*t.Repo) > 1000000 {
8000 return xerrors.Errorf("Value in field t.Repo was too long")
8001 }
8002
8003 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
8004 return err
8005 }
8006 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
8007 return err
8008 }
8009 }
8010 }
8011
8012 // t.Branch (string) (string)
8013 if len("branch") > 1000000 {
8014 return xerrors.Errorf("Value in field \"branch\" was too long")
8015 }
8016
8017 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
8018 return err
8019 }
8020 if _, err := cw.WriteString(string("branch")); err != nil {
8021 return err
8022 }
8023
8024 if len(t.Branch) > 1000000 {
8025 return xerrors.Errorf("Value in field t.Branch was too long")
8026 }
8027
8028 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
8029 return err
8030 }
8031 if _, err := cw.WriteString(string(t.Branch)); err != nil {
8032 return err
8033 }
8034 return nil
8035}
8036
8037func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) {
8038 *t = RepoPull_Source{}
8039
8040 cr := cbg.NewCborReader(r)
8041
8042 maj, extra, err := cr.ReadHeader()
8043 if err != nil {
8044 return err
8045 }
8046 defer func() {
8047 if err == io.EOF {
8048 err = io.ErrUnexpectedEOF
8049 }
8050 }()
8051
8052 if maj != cbg.MajMap {
8053 return fmt.Errorf("cbor input should be of type map")
8054 }
8055
8056 if extra > cbg.MaxLength {
8057 return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra)
8058 }
8059
8060 n := extra
8061
8062 nameBuf := make([]byte, 6)
8063 for i := uint64(0); i < n; i++ {
8064 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8065 if err != nil {
8066 return err
8067 }
8068
8069 if !ok {
8070 // Field doesn't exist on this type, so ignore it
8071 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8072 return err
8073 }
8074 continue
8075 }
8076
8077 switch string(nameBuf[:nameLen]) {
8078 // t.Sha (string) (string)
8079 case "sha":
8080
8081 {
8082 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8083 if err != nil {
8084 return err
8085 }
8086
8087 t.Sha = string(sval)
8088 }
8089 // t.Repo (string) (string)
8090 case "repo":
8091
8092 {
8093 b, err := cr.ReadByte()
8094 if err != nil {
8095 return err
8096 }
8097 if b != cbg.CborNull[0] {
8098 if err := cr.UnreadByte(); err != nil {
8099 return err
8100 }
8101
8102 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8103 if err != nil {
8104 return err
8105 }
8106
8107 t.Repo = (*string)(&sval)
8108 }
8109 }
8110 // t.Branch (string) (string)
8111 case "branch":
8112
8113 {
8114 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8115 if err != nil {
8116 return err
8117 }
8118
8119 t.Branch = string(sval)
8120 }
8121
8122 default:
8123 // Field doesn't exist on this type, so ignore it
8124 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8125 return err
8126 }
8127 }
8128 }
8129
8130 return nil
8131}
8132func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error {
8133 if t == nil {
8134 _, err := w.Write(cbg.CborNull)
8135 return err
8136 }
8137
8138 cw := cbg.NewCborWriter(w)
8139
8140 if _, err := cw.Write([]byte{163}); err != nil {
8141 return err
8142 }
8143
8144 // t.Pull (string) (string)
8145 if len("pull") > 1000000 {
8146 return xerrors.Errorf("Value in field \"pull\" was too long")
8147 }
8148
8149 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
8150 return err
8151 }
8152 if _, err := cw.WriteString(string("pull")); err != nil {
8153 return err
8154 }
8155
8156 if len(t.Pull) > 1000000 {
8157 return xerrors.Errorf("Value in field t.Pull was too long")
8158 }
8159
8160 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
8161 return err
8162 }
8163 if _, err := cw.WriteString(string(t.Pull)); err != nil {
8164 return err
8165 }
8166
8167 // t.LexiconTypeID (string) (string)
8168 if len("$type") > 1000000 {
8169 return xerrors.Errorf("Value in field \"$type\" was too long")
8170 }
8171
8172 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8173 return err
8174 }
8175 if _, err := cw.WriteString(string("$type")); err != nil {
8176 return err
8177 }
8178
8179 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil {
8180 return err
8181 }
8182 if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil {
8183 return err
8184 }
8185
8186 // t.Status (string) (string)
8187 if len("status") > 1000000 {
8188 return xerrors.Errorf("Value in field \"status\" was too long")
8189 }
8190
8191 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
8192 return err
8193 }
8194 if _, err := cw.WriteString(string("status")); err != nil {
8195 return err
8196 }
8197
8198 if len(t.Status) > 1000000 {
8199 return xerrors.Errorf("Value in field t.Status was too long")
8200 }
8201
8202 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
8203 return err
8204 }
8205 if _, err := cw.WriteString(string(t.Status)); err != nil {
8206 return err
8207 }
8208 return nil
8209}
8210
8211func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) {
8212 *t = RepoPullStatus{}
8213
8214 cr := cbg.NewCborReader(r)
8215
8216 maj, extra, err := cr.ReadHeader()
8217 if err != nil {
8218 return err
8219 }
8220 defer func() {
8221 if err == io.EOF {
8222 err = io.ErrUnexpectedEOF
8223 }
8224 }()
8225
8226 if maj != cbg.MajMap {
8227 return fmt.Errorf("cbor input should be of type map")
8228 }
8229
8230 if extra > cbg.MaxLength {
8231 return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra)
8232 }
8233
8234 n := extra
8235
8236 nameBuf := make([]byte, 6)
8237 for i := uint64(0); i < n; i++ {
8238 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8239 if err != nil {
8240 return err
8241 }
8242
8243 if !ok {
8244 // Field doesn't exist on this type, so ignore it
8245 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8246 return err
8247 }
8248 continue
8249 }
8250
8251 switch string(nameBuf[:nameLen]) {
8252 // t.Pull (string) (string)
8253 case "pull":
8254
8255 {
8256 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8257 if err != nil {
8258 return err
8259 }
8260
8261 t.Pull = string(sval)
8262 }
8263 // t.LexiconTypeID (string) (string)
8264 case "$type":
8265
8266 {
8267 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8268 if err != nil {
8269 return err
8270 }
8271
8272 t.LexiconTypeID = string(sval)
8273 }
8274 // t.Status (string) (string)
8275 case "status":
8276
8277 {
8278 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8279 if err != nil {
8280 return err
8281 }
8282
8283 t.Status = string(sval)
8284 }
8285
8286 default:
8287 // Field doesn't exist on this type, so ignore it
8288 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8289 return err
8290 }
8291 }
8292 }
8293
8294 return nil
8295}
8296func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error {
8297 if t == nil {
8298 _, err := w.Write(cbg.CborNull)
8299 return err
8300 }
8301
8302 cw := cbg.NewCborWriter(w)
8303
8304 if _, err := cw.Write([]byte{162}); err != nil {
8305 return err
8306 }
8307
8308 // t.Repo (string) (string)
8309 if len("repo") > 1000000 {
8310 return xerrors.Errorf("Value in field \"repo\" was too long")
8311 }
8312
8313 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
8314 return err
8315 }
8316 if _, err := cw.WriteString(string("repo")); err != nil {
8317 return err
8318 }
8319
8320 if len(t.Repo) > 1000000 {
8321 return xerrors.Errorf("Value in field t.Repo was too long")
8322 }
8323
8324 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
8325 return err
8326 }
8327 if _, err := cw.WriteString(string(t.Repo)); err != nil {
8328 return err
8329 }
8330
8331 // t.Branch (string) (string)
8332 if len("branch") > 1000000 {
8333 return xerrors.Errorf("Value in field \"branch\" was too long")
8334 }
8335
8336 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
8337 return err
8338 }
8339 if _, err := cw.WriteString(string("branch")); err != nil {
8340 return err
8341 }
8342
8343 if len(t.Branch) > 1000000 {
8344 return xerrors.Errorf("Value in field t.Branch was too long")
8345 }
8346
8347 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
8348 return err
8349 }
8350 if _, err := cw.WriteString(string(t.Branch)); err != nil {
8351 return err
8352 }
8353 return nil
8354}
8355
8356func (t *RepoPull_Target) UnmarshalCBOR(r io.Reader) (err error) {
8357 *t = RepoPull_Target{}
8358
8359 cr := cbg.NewCborReader(r)
8360
8361 maj, extra, err := cr.ReadHeader()
8362 if err != nil {
8363 return err
8364 }
8365 defer func() {
8366 if err == io.EOF {
8367 err = io.ErrUnexpectedEOF
8368 }
8369 }()
8370
8371 if maj != cbg.MajMap {
8372 return fmt.Errorf("cbor input should be of type map")
8373 }
8374
8375 if extra > cbg.MaxLength {
8376 return fmt.Errorf("RepoPull_Target: map struct too large (%d)", extra)
8377 }
8378
8379 n := extra
8380
8381 nameBuf := make([]byte, 6)
8382 for i := uint64(0); i < n; i++ {
8383 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8384 if err != nil {
8385 return err
8386 }
8387
8388 if !ok {
8389 // Field doesn't exist on this type, so ignore it
8390 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8391 return err
8392 }
8393 continue
8394 }
8395
8396 switch string(nameBuf[:nameLen]) {
8397 // t.Repo (string) (string)
8398 case "repo":
8399
8400 {
8401 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8402 if err != nil {
8403 return err
8404 }
8405
8406 t.Repo = string(sval)
8407 }
8408 // t.Branch (string) (string)
8409 case "branch":
8410
8411 {
8412 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8413 if err != nil {
8414 return err
8415 }
8416
8417 t.Branch = string(sval)
8418 }
8419
8420 default:
8421 // Field doesn't exist on this type, so ignore it
8422 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8423 return err
8424 }
8425 }
8426 }
8427
8428 return nil
8429}
8430func (t *Spindle) MarshalCBOR(w io.Writer) error {
8431 if t == nil {
8432 _, err := w.Write(cbg.CborNull)
8433 return err
8434 }
8435
8436 cw := cbg.NewCborWriter(w)
8437
8438 if _, err := cw.Write([]byte{162}); err != nil {
8439 return err
8440 }
8441
8442 // t.LexiconTypeID (string) (string)
8443 if len("$type") > 1000000 {
8444 return xerrors.Errorf("Value in field \"$type\" was too long")
8445 }
8446
8447 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8448 return err
8449 }
8450 if _, err := cw.WriteString(string("$type")); err != nil {
8451 return err
8452 }
8453
8454 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle"))); err != nil {
8455 return err
8456 }
8457 if _, err := cw.WriteString(string("sh.tangled.spindle")); err != nil {
8458 return err
8459 }
8460
8461 // t.CreatedAt (string) (string)
8462 if len("createdAt") > 1000000 {
8463 return xerrors.Errorf("Value in field \"createdAt\" was too long")
8464 }
8465
8466 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
8467 return err
8468 }
8469 if _, err := cw.WriteString(string("createdAt")); err != nil {
8470 return err
8471 }
8472
8473 if len(t.CreatedAt) > 1000000 {
8474 return xerrors.Errorf("Value in field t.CreatedAt was too long")
8475 }
8476
8477 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
8478 return err
8479 }
8480 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
8481 return err
8482 }
8483 return nil
8484}
8485
8486func (t *Spindle) UnmarshalCBOR(r io.Reader) (err error) {
8487 *t = Spindle{}
8488
8489 cr := cbg.NewCborReader(r)
8490
8491 maj, extra, err := cr.ReadHeader()
8492 if err != nil {
8493 return err
8494 }
8495 defer func() {
8496 if err == io.EOF {
8497 err = io.ErrUnexpectedEOF
8498 }
8499 }()
8500
8501 if maj != cbg.MajMap {
8502 return fmt.Errorf("cbor input should be of type map")
8503 }
8504
8505 if extra > cbg.MaxLength {
8506 return fmt.Errorf("Spindle: map struct too large (%d)", extra)
8507 }
8508
8509 n := extra
8510
8511 nameBuf := make([]byte, 9)
8512 for i := uint64(0); i < n; i++ {
8513 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8514 if err != nil {
8515 return err
8516 }
8517
8518 if !ok {
8519 // Field doesn't exist on this type, so ignore it
8520 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8521 return err
8522 }
8523 continue
8524 }
8525
8526 switch string(nameBuf[:nameLen]) {
8527 // t.LexiconTypeID (string) (string)
8528 case "$type":
8529
8530 {
8531 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8532 if err != nil {
8533 return err
8534 }
8535
8536 t.LexiconTypeID = string(sval)
8537 }
8538 // t.CreatedAt (string) (string)
8539 case "createdAt":
8540
8541 {
8542 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8543 if err != nil {
8544 return err
8545 }
8546
8547 t.CreatedAt = string(sval)
8548 }
8549
8550 default:
8551 // Field doesn't exist on this type, so ignore it
8552 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8553 return err
8554 }
8555 }
8556 }
8557
8558 return nil
8559}
8560func (t *SpindleMember) MarshalCBOR(w io.Writer) error {
8561 if t == nil {
8562 _, err := w.Write(cbg.CborNull)
8563 return err
8564 }
8565
8566 cw := cbg.NewCborWriter(w)
8567
8568 if _, err := cw.Write([]byte{164}); err != nil {
8569 return err
8570 }
8571
8572 // t.LexiconTypeID (string) (string)
8573 if len("$type") > 1000000 {
8574 return xerrors.Errorf("Value in field \"$type\" was too long")
8575 }
8576
8577 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8578 return err
8579 }
8580 if _, err := cw.WriteString(string("$type")); err != nil {
8581 return err
8582 }
8583
8584 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle.member"))); err != nil {
8585 return err
8586 }
8587 if _, err := cw.WriteString(string("sh.tangled.spindle.member")); err != nil {
8588 return err
8589 }
8590
8591 // t.Subject (string) (string)
8592 if len("subject") > 1000000 {
8593 return xerrors.Errorf("Value in field \"subject\" was too long")
8594 }
8595
8596 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
8597 return err
8598 }
8599 if _, err := cw.WriteString(string("subject")); err != nil {
8600 return err
8601 }
8602
8603 if len(t.Subject) > 1000000 {
8604 return xerrors.Errorf("Value in field t.Subject was too long")
8605 }
8606
8607 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
8608 return err
8609 }
8610 if _, err := cw.WriteString(string(t.Subject)); err != nil {
8611 return err
8612 }
8613
8614 // t.Instance (string) (string)
8615 if len("instance") > 1000000 {
8616 return xerrors.Errorf("Value in field \"instance\" was too long")
8617 }
8618
8619 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("instance"))); err != nil {
8620 return err
8621 }
8622 if _, err := cw.WriteString(string("instance")); err != nil {
8623 return err
8624 }
8625
8626 if len(t.Instance) > 1000000 {
8627 return xerrors.Errorf("Value in field t.Instance was too long")
8628 }
8629
8630 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Instance))); err != nil {
8631 return err
8632 }
8633 if _, err := cw.WriteString(string(t.Instance)); err != nil {
8634 return err
8635 }
8636
8637 // t.CreatedAt (string) (string)
8638 if len("createdAt") > 1000000 {
8639 return xerrors.Errorf("Value in field \"createdAt\" was too long")
8640 }
8641
8642 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
8643 return err
8644 }
8645 if _, err := cw.WriteString(string("createdAt")); err != nil {
8646 return err
8647 }
8648
8649 if len(t.CreatedAt) > 1000000 {
8650 return xerrors.Errorf("Value in field t.CreatedAt was too long")
8651 }
8652
8653 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
8654 return err
8655 }
8656 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
8657 return err
8658 }
8659 return nil
8660}
8661
8662func (t *SpindleMember) UnmarshalCBOR(r io.Reader) (err error) {
8663 *t = SpindleMember{}
8664
8665 cr := cbg.NewCborReader(r)
8666
8667 maj, extra, err := cr.ReadHeader()
8668 if err != nil {
8669 return err
8670 }
8671 defer func() {
8672 if err == io.EOF {
8673 err = io.ErrUnexpectedEOF
8674 }
8675 }()
8676
8677 if maj != cbg.MajMap {
8678 return fmt.Errorf("cbor input should be of type map")
8679 }
8680
8681 if extra > cbg.MaxLength {
8682 return fmt.Errorf("SpindleMember: map struct too large (%d)", extra)
8683 }
8684
8685 n := extra
8686
8687 nameBuf := make([]byte, 9)
8688 for i := uint64(0); i < n; i++ {
8689 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8690 if err != nil {
8691 return err
8692 }
8693
8694 if !ok {
8695 // Field doesn't exist on this type, so ignore it
8696 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8697 return err
8698 }
8699 continue
8700 }
8701
8702 switch string(nameBuf[:nameLen]) {
8703 // t.LexiconTypeID (string) (string)
8704 case "$type":
8705
8706 {
8707 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8708 if err != nil {
8709 return err
8710 }
8711
8712 t.LexiconTypeID = string(sval)
8713 }
8714 // t.Subject (string) (string)
8715 case "subject":
8716
8717 {
8718 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8719 if err != nil {
8720 return err
8721 }
8722
8723 t.Subject = string(sval)
8724 }
8725 // t.Instance (string) (string)
8726 case "instance":
8727
8728 {
8729 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8730 if err != nil {
8731 return err
8732 }
8733
8734 t.Instance = string(sval)
8735 }
8736 // t.CreatedAt (string) (string)
8737 case "createdAt":
8738
8739 {
8740 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8741 if err != nil {
8742 return err
8743 }
8744
8745 t.CreatedAt = string(sval)
8746 }
8747
8748 default:
8749 // Field doesn't exist on this type, so ignore it
8750 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8751 return err
8752 }
8753 }
8754 }
8755
8756 return nil
8757}
8758func (t *String) MarshalCBOR(w io.Writer) error {
8759 if t == nil {
8760 _, err := w.Write(cbg.CborNull)
8761 return err
8762 }
8763
8764 cw := cbg.NewCborWriter(w)
8765
8766 if _, err := cw.Write([]byte{165}); err != nil {
8767 return err
8768 }
8769
8770 // t.LexiconTypeID (string) (string)
8771 if len("$type") > 1000000 {
8772 return xerrors.Errorf("Value in field \"$type\" was too long")
8773 }
8774
8775 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8776 return err
8777 }
8778 if _, err := cw.WriteString(string("$type")); err != nil {
8779 return err
8780 }
8781
8782 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.string"))); err != nil {
8783 return err
8784 }
8785 if _, err := cw.WriteString(string("sh.tangled.string")); err != nil {
8786 return err
8787 }
8788
8789 // t.Contents (string) (string)
8790 if len("contents") > 1000000 {
8791 return xerrors.Errorf("Value in field \"contents\" was too long")
8792 }
8793
8794 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("contents"))); err != nil {
8795 return err
8796 }
8797 if _, err := cw.WriteString(string("contents")); err != nil {
8798 return err
8799 }
8800
8801 if len(t.Contents) > 1000000 {
8802 return xerrors.Errorf("Value in field t.Contents was too long")
8803 }
8804
8805 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Contents))); err != nil {
8806 return err
8807 }
8808 if _, err := cw.WriteString(string(t.Contents)); err != nil {
8809 return err
8810 }
8811
8812 // t.Filename (string) (string)
8813 if len("filename") > 1000000 {
8814 return xerrors.Errorf("Value in field \"filename\" was too long")
8815 }
8816
8817 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("filename"))); err != nil {
8818 return err
8819 }
8820 if _, err := cw.WriteString(string("filename")); err != nil {
8821 return err
8822 }
8823
8824 if len(t.Filename) > 1000000 {
8825 return xerrors.Errorf("Value in field t.Filename was too long")
8826 }
8827
8828 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Filename))); err != nil {
8829 return err
8830 }
8831 if _, err := cw.WriteString(string(t.Filename)); err != nil {
8832 return err
8833 }
8834
8835 // t.CreatedAt (string) (string)
8836 if len("createdAt") > 1000000 {
8837 return xerrors.Errorf("Value in field \"createdAt\" was too long")
8838 }
8839
8840 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
8841 return err
8842 }
8843 if _, err := cw.WriteString(string("createdAt")); err != nil {
8844 return err
8845 }
8846
8847 if len(t.CreatedAt) > 1000000 {
8848 return xerrors.Errorf("Value in field t.CreatedAt was too long")
8849 }
8850
8851 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
8852 return err
8853 }
8854 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
8855 return err
8856 }
8857
8858 // t.Description (string) (string)
8859 if len("description") > 1000000 {
8860 return xerrors.Errorf("Value in field \"description\" was too long")
8861 }
8862
8863 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
8864 return err
8865 }
8866 if _, err := cw.WriteString(string("description")); err != nil {
8867 return err
8868 }
8869
8870 if len(t.Description) > 1000000 {
8871 return xerrors.Errorf("Value in field t.Description was too long")
8872 }
8873
8874 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil {
8875 return err
8876 }
8877 if _, err := cw.WriteString(string(t.Description)); err != nil {
8878 return err
8879 }
8880 return nil
8881}
8882
8883func (t *String) UnmarshalCBOR(r io.Reader) (err error) {
8884 *t = String{}
8885
8886 cr := cbg.NewCborReader(r)
8887
8888 maj, extra, err := cr.ReadHeader()
8889 if err != nil {
8890 return err
8891 }
8892 defer func() {
8893 if err == io.EOF {
8894 err = io.ErrUnexpectedEOF
8895 }
8896 }()
8897
8898 if maj != cbg.MajMap {
8899 return fmt.Errorf("cbor input should be of type map")
8900 }
8901
8902 if extra > cbg.MaxLength {
8903 return fmt.Errorf("String: map struct too large (%d)", extra)
8904 }
8905
8906 n := extra
8907
8908 nameBuf := make([]byte, 11)
8909 for i := uint64(0); i < n; i++ {
8910 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8911 if err != nil {
8912 return err
8913 }
8914
8915 if !ok {
8916 // Field doesn't exist on this type, so ignore it
8917 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8918 return err
8919 }
8920 continue
8921 }
8922
8923 switch string(nameBuf[:nameLen]) {
8924 // t.LexiconTypeID (string) (string)
8925 case "$type":
8926
8927 {
8928 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8929 if err != nil {
8930 return err
8931 }
8932
8933 t.LexiconTypeID = string(sval)
8934 }
8935 // t.Contents (string) (string)
8936 case "contents":
8937
8938 {
8939 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8940 if err != nil {
8941 return err
8942 }
8943
8944 t.Contents = string(sval)
8945 }
8946 // t.Filename (string) (string)
8947 case "filename":
8948
8949 {
8950 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8951 if err != nil {
8952 return err
8953 }
8954
8955 t.Filename = string(sval)
8956 }
8957 // t.CreatedAt (string) (string)
8958 case "createdAt":
8959
8960 {
8961 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8962 if err != nil {
8963 return err
8964 }
8965
8966 t.CreatedAt = string(sval)
8967 }
8968 // t.Description (string) (string)
8969 case "description":
8970
8971 {
8972 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8973 if err != nil {
8974 return err
8975 }
8976
8977 t.Description = string(sval)
8978 }
8979
8980 default:
8981 // Field doesn't exist on this type, so ignore it
8982 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8983 return err
8984 }
8985 }
8986 }
8987
8988 return nil
8989}