julien.rbrt.fr
forked from
tangled.org/core
Monorepo for Tangled — https://tangled.org
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_Meta) 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 := 3
1213
1214 if t.LangBreakdown == 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.CommitCount (tangled.GitRefUpdate_Meta_CommitCount) (struct)
1223 if len("commitCount") > 1000000 {
1224 return xerrors.Errorf("Value in field \"commitCount\" was too long")
1225 }
1226
1227 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commitCount"))); err != nil {
1228 return err
1229 }
1230 if _, err := cw.WriteString(string("commitCount")); err != nil {
1231 return err
1232 }
1233
1234 if err := t.CommitCount.MarshalCBOR(cw); err != nil {
1235 return err
1236 }
1237
1238 // t.IsDefaultRef (bool) (bool)
1239 if len("isDefaultRef") > 1000000 {
1240 return xerrors.Errorf("Value in field \"isDefaultRef\" was too long")
1241 }
1242
1243 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("isDefaultRef"))); err != nil {
1244 return err
1245 }
1246 if _, err := cw.WriteString(string("isDefaultRef")); err != nil {
1247 return err
1248 }
1249
1250 if err := cbg.WriteBool(w, t.IsDefaultRef); err != nil {
1251 return err
1252 }
1253
1254 // t.LangBreakdown (tangled.GitRefUpdate_Meta_LangBreakdown) (struct)
1255 if t.LangBreakdown != nil {
1256
1257 if len("langBreakdown") > 1000000 {
1258 return xerrors.Errorf("Value in field \"langBreakdown\" was too long")
1259 }
1260
1261 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("langBreakdown"))); err != nil {
1262 return err
1263 }
1264 if _, err := cw.WriteString(string("langBreakdown")); err != nil {
1265 return err
1266 }
1267
1268 if err := t.LangBreakdown.MarshalCBOR(cw); err != nil {
1269 return err
1270 }
1271 }
1272 return nil
1273}
1274
1275func (t *GitRefUpdate_Meta) UnmarshalCBOR(r io.Reader) (err error) {
1276 *t = GitRefUpdate_Meta{}
1277
1278 cr := cbg.NewCborReader(r)
1279
1280 maj, extra, err := cr.ReadHeader()
1281 if err != nil {
1282 return err
1283 }
1284 defer func() {
1285 if err == io.EOF {
1286 err = io.ErrUnexpectedEOF
1287 }
1288 }()
1289
1290 if maj != cbg.MajMap {
1291 return fmt.Errorf("cbor input should be of type map")
1292 }
1293
1294 if extra > cbg.MaxLength {
1295 return fmt.Errorf("GitRefUpdate_Meta: map struct too large (%d)", extra)
1296 }
1297
1298 n := extra
1299
1300 nameBuf := make([]byte, 13)
1301 for i := uint64(0); i < n; i++ {
1302 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1303 if err != nil {
1304 return err
1305 }
1306
1307 if !ok {
1308 // Field doesn't exist on this type, so ignore it
1309 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1310 return err
1311 }
1312 continue
1313 }
1314
1315 switch string(nameBuf[:nameLen]) {
1316 // t.CommitCount (tangled.GitRefUpdate_Meta_CommitCount) (struct)
1317 case "commitCount":
1318
1319 {
1320
1321 b, err := cr.ReadByte()
1322 if err != nil {
1323 return err
1324 }
1325 if b != cbg.CborNull[0] {
1326 if err := cr.UnreadByte(); err != nil {
1327 return err
1328 }
1329 t.CommitCount = new(GitRefUpdate_Meta_CommitCount)
1330 if err := t.CommitCount.UnmarshalCBOR(cr); err != nil {
1331 return xerrors.Errorf("unmarshaling t.CommitCount pointer: %w", err)
1332 }
1333 }
1334
1335 }
1336 // t.IsDefaultRef (bool) (bool)
1337 case "isDefaultRef":
1338
1339 maj, extra, err = cr.ReadHeader()
1340 if err != nil {
1341 return err
1342 }
1343 if maj != cbg.MajOther {
1344 return fmt.Errorf("booleans must be major type 7")
1345 }
1346 switch extra {
1347 case 20:
1348 t.IsDefaultRef = false
1349 case 21:
1350 t.IsDefaultRef = true
1351 default:
1352 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
1353 }
1354 // t.LangBreakdown (tangled.GitRefUpdate_Meta_LangBreakdown) (struct)
1355 case "langBreakdown":
1356
1357 {
1358
1359 b, err := cr.ReadByte()
1360 if err != nil {
1361 return err
1362 }
1363 if b != cbg.CborNull[0] {
1364 if err := cr.UnreadByte(); err != nil {
1365 return err
1366 }
1367 t.LangBreakdown = new(GitRefUpdate_Meta_LangBreakdown)
1368 if err := t.LangBreakdown.UnmarshalCBOR(cr); err != nil {
1369 return xerrors.Errorf("unmarshaling t.LangBreakdown pointer: %w", err)
1370 }
1371 }
1372
1373 }
1374
1375 default:
1376 // Field doesn't exist on this type, so ignore it
1377 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1378 return err
1379 }
1380 }
1381 }
1382
1383 return nil
1384}
1385func (t *GitRefUpdate_Meta_CommitCount) MarshalCBOR(w io.Writer) error {
1386 if t == nil {
1387 _, err := w.Write(cbg.CborNull)
1388 return err
1389 }
1390
1391 cw := cbg.NewCborWriter(w)
1392 fieldCount := 1
1393
1394 if t.ByEmail == nil {
1395 fieldCount--
1396 }
1397
1398 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1399 return err
1400 }
1401
1402 // t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice)
1403 if t.ByEmail != nil {
1404
1405 if len("byEmail") > 1000000 {
1406 return xerrors.Errorf("Value in field \"byEmail\" was too long")
1407 }
1408
1409 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byEmail"))); err != nil {
1410 return err
1411 }
1412 if _, err := cw.WriteString(string("byEmail")); err != nil {
1413 return err
1414 }
1415
1416 if len(t.ByEmail) > 8192 {
1417 return xerrors.Errorf("Slice value in field t.ByEmail was too long")
1418 }
1419
1420 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ByEmail))); err != nil {
1421 return err
1422 }
1423 for _, v := range t.ByEmail {
1424 if err := v.MarshalCBOR(cw); err != nil {
1425 return err
1426 }
1427
1428 }
1429 }
1430 return nil
1431}
1432
1433func (t *GitRefUpdate_Meta_CommitCount) UnmarshalCBOR(r io.Reader) (err error) {
1434 *t = GitRefUpdate_Meta_CommitCount{}
1435
1436 cr := cbg.NewCborReader(r)
1437
1438 maj, extra, err := cr.ReadHeader()
1439 if err != nil {
1440 return err
1441 }
1442 defer func() {
1443 if err == io.EOF {
1444 err = io.ErrUnexpectedEOF
1445 }
1446 }()
1447
1448 if maj != cbg.MajMap {
1449 return fmt.Errorf("cbor input should be of type map")
1450 }
1451
1452 if extra > cbg.MaxLength {
1453 return fmt.Errorf("GitRefUpdate_Meta_CommitCount: map struct too large (%d)", extra)
1454 }
1455
1456 n := extra
1457
1458 nameBuf := make([]byte, 7)
1459 for i := uint64(0); i < n; i++ {
1460 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1461 if err != nil {
1462 return err
1463 }
1464
1465 if !ok {
1466 // Field doesn't exist on this type, so ignore it
1467 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1468 return err
1469 }
1470 continue
1471 }
1472
1473 switch string(nameBuf[:nameLen]) {
1474 // t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice)
1475 case "byEmail":
1476
1477 maj, extra, err = cr.ReadHeader()
1478 if err != nil {
1479 return err
1480 }
1481
1482 if extra > 8192 {
1483 return fmt.Errorf("t.ByEmail: array too large (%d)", extra)
1484 }
1485
1486 if maj != cbg.MajArray {
1487 return fmt.Errorf("expected cbor array")
1488 }
1489
1490 if extra > 0 {
1491 t.ByEmail = make([]*GitRefUpdate_Meta_CommitCount_ByEmail_Elem, extra)
1492 }
1493
1494 for i := 0; i < int(extra); i++ {
1495 {
1496 var maj byte
1497 var extra uint64
1498 var err error
1499 _ = maj
1500 _ = extra
1501 _ = err
1502
1503 {
1504
1505 b, err := cr.ReadByte()
1506 if err != nil {
1507 return err
1508 }
1509 if b != cbg.CborNull[0] {
1510 if err := cr.UnreadByte(); err != nil {
1511 return err
1512 }
1513 t.ByEmail[i] = new(GitRefUpdate_Meta_CommitCount_ByEmail_Elem)
1514 if err := t.ByEmail[i].UnmarshalCBOR(cr); err != nil {
1515 return xerrors.Errorf("unmarshaling t.ByEmail[i] pointer: %w", err)
1516 }
1517 }
1518
1519 }
1520
1521 }
1522 }
1523
1524 default:
1525 // Field doesn't exist on this type, so ignore it
1526 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1527 return err
1528 }
1529 }
1530 }
1531
1532 return nil
1533}
1534func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) MarshalCBOR(w io.Writer) error {
1535 if t == nil {
1536 _, err := w.Write(cbg.CborNull)
1537 return err
1538 }
1539
1540 cw := cbg.NewCborWriter(w)
1541
1542 if _, err := cw.Write([]byte{162}); err != nil {
1543 return err
1544 }
1545
1546 // t.Count (int64) (int64)
1547 if len("count") > 1000000 {
1548 return xerrors.Errorf("Value in field \"count\" was too long")
1549 }
1550
1551 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("count"))); err != nil {
1552 return err
1553 }
1554 if _, err := cw.WriteString(string("count")); err != nil {
1555 return err
1556 }
1557
1558 if t.Count >= 0 {
1559 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Count)); err != nil {
1560 return err
1561 }
1562 } else {
1563 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Count-1)); err != nil {
1564 return err
1565 }
1566 }
1567
1568 // t.Email (string) (string)
1569 if len("email") > 1000000 {
1570 return xerrors.Errorf("Value in field \"email\" was too long")
1571 }
1572
1573 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("email"))); err != nil {
1574 return err
1575 }
1576 if _, err := cw.WriteString(string("email")); err != nil {
1577 return err
1578 }
1579
1580 if len(t.Email) > 1000000 {
1581 return xerrors.Errorf("Value in field t.Email was too long")
1582 }
1583
1584 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Email))); err != nil {
1585 return err
1586 }
1587 if _, err := cw.WriteString(string(t.Email)); err != nil {
1588 return err
1589 }
1590 return nil
1591}
1592
1593func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) UnmarshalCBOR(r io.Reader) (err error) {
1594 *t = GitRefUpdate_Meta_CommitCount_ByEmail_Elem{}
1595
1596 cr := cbg.NewCborReader(r)
1597
1598 maj, extra, err := cr.ReadHeader()
1599 if err != nil {
1600 return err
1601 }
1602 defer func() {
1603 if err == io.EOF {
1604 err = io.ErrUnexpectedEOF
1605 }
1606 }()
1607
1608 if maj != cbg.MajMap {
1609 return fmt.Errorf("cbor input should be of type map")
1610 }
1611
1612 if extra > cbg.MaxLength {
1613 return fmt.Errorf("GitRefUpdate_Meta_CommitCount_ByEmail_Elem: map struct too large (%d)", extra)
1614 }
1615
1616 n := extra
1617
1618 nameBuf := make([]byte, 5)
1619 for i := uint64(0); i < n; i++ {
1620 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1621 if err != nil {
1622 return err
1623 }
1624
1625 if !ok {
1626 // Field doesn't exist on this type, so ignore it
1627 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1628 return err
1629 }
1630 continue
1631 }
1632
1633 switch string(nameBuf[:nameLen]) {
1634 // t.Count (int64) (int64)
1635 case "count":
1636 {
1637 maj, extra, err := cr.ReadHeader()
1638 if err != nil {
1639 return err
1640 }
1641 var extraI int64
1642 switch maj {
1643 case cbg.MajUnsignedInt:
1644 extraI = int64(extra)
1645 if extraI < 0 {
1646 return fmt.Errorf("int64 positive overflow")
1647 }
1648 case cbg.MajNegativeInt:
1649 extraI = int64(extra)
1650 if extraI < 0 {
1651 return fmt.Errorf("int64 negative overflow")
1652 }
1653 extraI = -1 - extraI
1654 default:
1655 return fmt.Errorf("wrong type for int64 field: %d", maj)
1656 }
1657
1658 t.Count = int64(extraI)
1659 }
1660 // t.Email (string) (string)
1661 case "email":
1662
1663 {
1664 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1665 if err != nil {
1666 return err
1667 }
1668
1669 t.Email = string(sval)
1670 }
1671
1672 default:
1673 // Field doesn't exist on this type, so ignore it
1674 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1675 return err
1676 }
1677 }
1678 }
1679
1680 return nil
1681}
1682func (t *GitRefUpdate_Meta_LangBreakdown) MarshalCBOR(w io.Writer) error {
1683 if t == nil {
1684 _, err := w.Write(cbg.CborNull)
1685 return err
1686 }
1687
1688 cw := cbg.NewCborWriter(w)
1689 fieldCount := 1
1690
1691 if t.Inputs == nil {
1692 fieldCount--
1693 }
1694
1695 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1696 return err
1697 }
1698
1699 // t.Inputs ([]*tangled.GitRefUpdate_Pair) (slice)
1700 if t.Inputs != nil {
1701
1702 if len("inputs") > 1000000 {
1703 return xerrors.Errorf("Value in field \"inputs\" was too long")
1704 }
1705
1706 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
1707 return err
1708 }
1709 if _, err := cw.WriteString(string("inputs")); err != nil {
1710 return err
1711 }
1712
1713 if len(t.Inputs) > 8192 {
1714 return xerrors.Errorf("Slice value in field t.Inputs was too long")
1715 }
1716
1717 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
1718 return err
1719 }
1720 for _, v := range t.Inputs {
1721 if err := v.MarshalCBOR(cw); err != nil {
1722 return err
1723 }
1724
1725 }
1726 }
1727 return nil
1728}
1729
1730func (t *GitRefUpdate_Meta_LangBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
1731 *t = GitRefUpdate_Meta_LangBreakdown{}
1732
1733 cr := cbg.NewCborReader(r)
1734
1735 maj, extra, err := cr.ReadHeader()
1736 if err != nil {
1737 return err
1738 }
1739 defer func() {
1740 if err == io.EOF {
1741 err = io.ErrUnexpectedEOF
1742 }
1743 }()
1744
1745 if maj != cbg.MajMap {
1746 return fmt.Errorf("cbor input should be of type map")
1747 }
1748
1749 if extra > cbg.MaxLength {
1750 return fmt.Errorf("GitRefUpdate_Meta_LangBreakdown: map struct too large (%d)", extra)
1751 }
1752
1753 n := extra
1754
1755 nameBuf := make([]byte, 6)
1756 for i := uint64(0); i < n; i++ {
1757 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1758 if err != nil {
1759 return err
1760 }
1761
1762 if !ok {
1763 // Field doesn't exist on this type, so ignore it
1764 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1765 return err
1766 }
1767 continue
1768 }
1769
1770 switch string(nameBuf[:nameLen]) {
1771 // t.Inputs ([]*tangled.GitRefUpdate_Pair) (slice)
1772 case "inputs":
1773
1774 maj, extra, err = cr.ReadHeader()
1775 if err != nil {
1776 return err
1777 }
1778
1779 if extra > 8192 {
1780 return fmt.Errorf("t.Inputs: array too large (%d)", extra)
1781 }
1782
1783 if maj != cbg.MajArray {
1784 return fmt.Errorf("expected cbor array")
1785 }
1786
1787 if extra > 0 {
1788 t.Inputs = make([]*GitRefUpdate_Pair, extra)
1789 }
1790
1791 for i := 0; i < int(extra); i++ {
1792 {
1793 var maj byte
1794 var extra uint64
1795 var err error
1796 _ = maj
1797 _ = extra
1798 _ = err
1799
1800 {
1801
1802 b, err := cr.ReadByte()
1803 if err != nil {
1804 return err
1805 }
1806 if b != cbg.CborNull[0] {
1807 if err := cr.UnreadByte(); err != nil {
1808 return err
1809 }
1810 t.Inputs[i] = new(GitRefUpdate_Pair)
1811 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
1812 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
1813 }
1814 }
1815
1816 }
1817
1818 }
1819 }
1820
1821 default:
1822 // Field doesn't exist on this type, so ignore it
1823 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1824 return err
1825 }
1826 }
1827 }
1828
1829 return nil
1830}
1831func (t *GitRefUpdate_Pair) MarshalCBOR(w io.Writer) error {
1832 if t == nil {
1833 _, err := w.Write(cbg.CborNull)
1834 return err
1835 }
1836
1837 cw := cbg.NewCborWriter(w)
1838
1839 if _, err := cw.Write([]byte{162}); err != nil {
1840 return err
1841 }
1842
1843 // t.Lang (string) (string)
1844 if len("lang") > 1000000 {
1845 return xerrors.Errorf("Value in field \"lang\" was too long")
1846 }
1847
1848 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil {
1849 return err
1850 }
1851 if _, err := cw.WriteString(string("lang")); err != nil {
1852 return err
1853 }
1854
1855 if len(t.Lang) > 1000000 {
1856 return xerrors.Errorf("Value in field t.Lang was too long")
1857 }
1858
1859 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil {
1860 return err
1861 }
1862 if _, err := cw.WriteString(string(t.Lang)); err != nil {
1863 return err
1864 }
1865
1866 // t.Size (int64) (int64)
1867 if len("size") > 1000000 {
1868 return xerrors.Errorf("Value in field \"size\" was too long")
1869 }
1870
1871 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil {
1872 return err
1873 }
1874 if _, err := cw.WriteString(string("size")); err != nil {
1875 return err
1876 }
1877
1878 if t.Size >= 0 {
1879 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil {
1880 return err
1881 }
1882 } else {
1883 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); err != nil {
1884 return err
1885 }
1886 }
1887
1888 return nil
1889}
1890
1891func (t *GitRefUpdate_Pair) UnmarshalCBOR(r io.Reader) (err error) {
1892 *t = GitRefUpdate_Pair{}
1893
1894 cr := cbg.NewCborReader(r)
1895
1896 maj, extra, err := cr.ReadHeader()
1897 if err != nil {
1898 return err
1899 }
1900 defer func() {
1901 if err == io.EOF {
1902 err = io.ErrUnexpectedEOF
1903 }
1904 }()
1905
1906 if maj != cbg.MajMap {
1907 return fmt.Errorf("cbor input should be of type map")
1908 }
1909
1910 if extra > cbg.MaxLength {
1911 return fmt.Errorf("GitRefUpdate_Pair: map struct too large (%d)", extra)
1912 }
1913
1914 n := extra
1915
1916 nameBuf := make([]byte, 4)
1917 for i := uint64(0); i < n; i++ {
1918 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1919 if err != nil {
1920 return err
1921 }
1922
1923 if !ok {
1924 // Field doesn't exist on this type, so ignore it
1925 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1926 return err
1927 }
1928 continue
1929 }
1930
1931 switch string(nameBuf[:nameLen]) {
1932 // t.Lang (string) (string)
1933 case "lang":
1934
1935 {
1936 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1937 if err != nil {
1938 return err
1939 }
1940
1941 t.Lang = string(sval)
1942 }
1943 // t.Size (int64) (int64)
1944 case "size":
1945 {
1946 maj, extra, err := cr.ReadHeader()
1947 if err != nil {
1948 return err
1949 }
1950 var extraI int64
1951 switch maj {
1952 case cbg.MajUnsignedInt:
1953 extraI = int64(extra)
1954 if extraI < 0 {
1955 return fmt.Errorf("int64 positive overflow")
1956 }
1957 case cbg.MajNegativeInt:
1958 extraI = int64(extra)
1959 if extraI < 0 {
1960 return fmt.Errorf("int64 negative overflow")
1961 }
1962 extraI = -1 - extraI
1963 default:
1964 return fmt.Errorf("wrong type for int64 field: %d", maj)
1965 }
1966
1967 t.Size = int64(extraI)
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 *Pipeline) 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
2480 if _, err := cw.Write([]byte{163}); err != nil {
2481 return err
2482 }
2483
2484 // t.LexiconTypeID (string) (string)
2485 if len("$type") > 1000000 {
2486 return xerrors.Errorf("Value in field \"$type\" was too long")
2487 }
2488
2489 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2490 return err
2491 }
2492 if _, err := cw.WriteString(string("$type")); err != nil {
2493 return err
2494 }
2495
2496 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil {
2497 return err
2498 }
2499 if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil {
2500 return err
2501 }
2502
2503 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
2504 if len("workflows") > 1000000 {
2505 return xerrors.Errorf("Value in field \"workflows\" was too long")
2506 }
2507
2508 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil {
2509 return err
2510 }
2511 if _, err := cw.WriteString(string("workflows")); err != nil {
2512 return err
2513 }
2514
2515 if len(t.Workflows) > 8192 {
2516 return xerrors.Errorf("Slice value in field t.Workflows was too long")
2517 }
2518
2519 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil {
2520 return err
2521 }
2522 for _, v := range t.Workflows {
2523 if err := v.MarshalCBOR(cw); err != nil {
2524 return err
2525 }
2526
2527 }
2528
2529 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
2530 if len("triggerMetadata") > 1000000 {
2531 return xerrors.Errorf("Value in field \"triggerMetadata\" was too long")
2532 }
2533
2534 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil {
2535 return err
2536 }
2537 if _, err := cw.WriteString(string("triggerMetadata")); err != nil {
2538 return err
2539 }
2540
2541 if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil {
2542 return err
2543 }
2544 return nil
2545}
2546
2547func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) {
2548 *t = Pipeline{}
2549
2550 cr := cbg.NewCborReader(r)
2551
2552 maj, extra, err := cr.ReadHeader()
2553 if err != nil {
2554 return err
2555 }
2556 defer func() {
2557 if err == io.EOF {
2558 err = io.ErrUnexpectedEOF
2559 }
2560 }()
2561
2562 if maj != cbg.MajMap {
2563 return fmt.Errorf("cbor input should be of type map")
2564 }
2565
2566 if extra > cbg.MaxLength {
2567 return fmt.Errorf("Pipeline: map struct too large (%d)", extra)
2568 }
2569
2570 n := extra
2571
2572 nameBuf := make([]byte, 15)
2573 for i := uint64(0); i < n; i++ {
2574 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2575 if err != nil {
2576 return err
2577 }
2578
2579 if !ok {
2580 // Field doesn't exist on this type, so ignore it
2581 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2582 return err
2583 }
2584 continue
2585 }
2586
2587 switch string(nameBuf[:nameLen]) {
2588 // t.LexiconTypeID (string) (string)
2589 case "$type":
2590
2591 {
2592 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2593 if err != nil {
2594 return err
2595 }
2596
2597 t.LexiconTypeID = string(sval)
2598 }
2599 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
2600 case "workflows":
2601
2602 maj, extra, err = cr.ReadHeader()
2603 if err != nil {
2604 return err
2605 }
2606
2607 if extra > 8192 {
2608 return fmt.Errorf("t.Workflows: array too large (%d)", extra)
2609 }
2610
2611 if maj != cbg.MajArray {
2612 return fmt.Errorf("expected cbor array")
2613 }
2614
2615 if extra > 0 {
2616 t.Workflows = make([]*Pipeline_Workflow, extra)
2617 }
2618
2619 for i := 0; i < int(extra); i++ {
2620 {
2621 var maj byte
2622 var extra uint64
2623 var err error
2624 _ = maj
2625 _ = extra
2626 _ = err
2627
2628 {
2629
2630 b, err := cr.ReadByte()
2631 if err != nil {
2632 return err
2633 }
2634 if b != cbg.CborNull[0] {
2635 if err := cr.UnreadByte(); err != nil {
2636 return err
2637 }
2638 t.Workflows[i] = new(Pipeline_Workflow)
2639 if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil {
2640 return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err)
2641 }
2642 }
2643
2644 }
2645
2646 }
2647 }
2648 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
2649 case "triggerMetadata":
2650
2651 {
2652
2653 b, err := cr.ReadByte()
2654 if err != nil {
2655 return err
2656 }
2657 if b != cbg.CborNull[0] {
2658 if err := cr.UnreadByte(); err != nil {
2659 return err
2660 }
2661 t.TriggerMetadata = new(Pipeline_TriggerMetadata)
2662 if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil {
2663 return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err)
2664 }
2665 }
2666
2667 }
2668
2669 default:
2670 // Field doesn't exist on this type, so ignore it
2671 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2672 return err
2673 }
2674 }
2675 }
2676
2677 return nil
2678}
2679func (t *Pipeline_CloneOpts) MarshalCBOR(w io.Writer) error {
2680 if t == nil {
2681 _, err := w.Write(cbg.CborNull)
2682 return err
2683 }
2684
2685 cw := cbg.NewCborWriter(w)
2686
2687 if _, err := cw.Write([]byte{163}); err != nil {
2688 return err
2689 }
2690
2691 // t.Skip (bool) (bool)
2692 if len("skip") > 1000000 {
2693 return xerrors.Errorf("Value in field \"skip\" was too long")
2694 }
2695
2696 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("skip"))); err != nil {
2697 return err
2698 }
2699 if _, err := cw.WriteString(string("skip")); err != nil {
2700 return err
2701 }
2702
2703 if err := cbg.WriteBool(w, t.Skip); err != nil {
2704 return err
2705 }
2706
2707 // t.Depth (int64) (int64)
2708 if len("depth") > 1000000 {
2709 return xerrors.Errorf("Value in field \"depth\" was too long")
2710 }
2711
2712 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("depth"))); err != nil {
2713 return err
2714 }
2715 if _, err := cw.WriteString(string("depth")); err != nil {
2716 return err
2717 }
2718
2719 if t.Depth >= 0 {
2720 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Depth)); err != nil {
2721 return err
2722 }
2723 } else {
2724 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Depth-1)); err != nil {
2725 return err
2726 }
2727 }
2728
2729 // t.Submodules (bool) (bool)
2730 if len("submodules") > 1000000 {
2731 return xerrors.Errorf("Value in field \"submodules\" was too long")
2732 }
2733
2734 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("submodules"))); err != nil {
2735 return err
2736 }
2737 if _, err := cw.WriteString(string("submodules")); err != nil {
2738 return err
2739 }
2740
2741 if err := cbg.WriteBool(w, t.Submodules); err != nil {
2742 return err
2743 }
2744 return nil
2745}
2746
2747func (t *Pipeline_CloneOpts) UnmarshalCBOR(r io.Reader) (err error) {
2748 *t = Pipeline_CloneOpts{}
2749
2750 cr := cbg.NewCborReader(r)
2751
2752 maj, extra, err := cr.ReadHeader()
2753 if err != nil {
2754 return err
2755 }
2756 defer func() {
2757 if err == io.EOF {
2758 err = io.ErrUnexpectedEOF
2759 }
2760 }()
2761
2762 if maj != cbg.MajMap {
2763 return fmt.Errorf("cbor input should be of type map")
2764 }
2765
2766 if extra > cbg.MaxLength {
2767 return fmt.Errorf("Pipeline_CloneOpts: map struct too large (%d)", extra)
2768 }
2769
2770 n := extra
2771
2772 nameBuf := make([]byte, 10)
2773 for i := uint64(0); i < n; i++ {
2774 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2775 if err != nil {
2776 return err
2777 }
2778
2779 if !ok {
2780 // Field doesn't exist on this type, so ignore it
2781 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2782 return err
2783 }
2784 continue
2785 }
2786
2787 switch string(nameBuf[:nameLen]) {
2788 // t.Skip (bool) (bool)
2789 case "skip":
2790
2791 maj, extra, err = cr.ReadHeader()
2792 if err != nil {
2793 return err
2794 }
2795 if maj != cbg.MajOther {
2796 return fmt.Errorf("booleans must be major type 7")
2797 }
2798 switch extra {
2799 case 20:
2800 t.Skip = false
2801 case 21:
2802 t.Skip = true
2803 default:
2804 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
2805 }
2806 // t.Depth (int64) (int64)
2807 case "depth":
2808 {
2809 maj, extra, err := cr.ReadHeader()
2810 if err != nil {
2811 return err
2812 }
2813 var extraI int64
2814 switch maj {
2815 case cbg.MajUnsignedInt:
2816 extraI = int64(extra)
2817 if extraI < 0 {
2818 return fmt.Errorf("int64 positive overflow")
2819 }
2820 case cbg.MajNegativeInt:
2821 extraI = int64(extra)
2822 if extraI < 0 {
2823 return fmt.Errorf("int64 negative overflow")
2824 }
2825 extraI = -1 - extraI
2826 default:
2827 return fmt.Errorf("wrong type for int64 field: %d", maj)
2828 }
2829
2830 t.Depth = int64(extraI)
2831 }
2832 // t.Submodules (bool) (bool)
2833 case "submodules":
2834
2835 maj, extra, err = cr.ReadHeader()
2836 if err != nil {
2837 return err
2838 }
2839 if maj != cbg.MajOther {
2840 return fmt.Errorf("booleans must be major type 7")
2841 }
2842 switch extra {
2843 case 20:
2844 t.Submodules = false
2845 case 21:
2846 t.Submodules = true
2847 default:
2848 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
2849 }
2850
2851 default:
2852 // Field doesn't exist on this type, so ignore it
2853 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2854 return err
2855 }
2856 }
2857 }
2858
2859 return nil
2860}
2861func (t *Pipeline_ManualTriggerData) MarshalCBOR(w io.Writer) error {
2862 if t == nil {
2863 _, err := w.Write(cbg.CborNull)
2864 return err
2865 }
2866
2867 cw := cbg.NewCborWriter(w)
2868 fieldCount := 1
2869
2870 if t.Inputs == nil {
2871 fieldCount--
2872 }
2873
2874 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2875 return err
2876 }
2877
2878 // t.Inputs ([]*tangled.Pipeline_Pair) (slice)
2879 if t.Inputs != nil {
2880
2881 if len("inputs") > 1000000 {
2882 return xerrors.Errorf("Value in field \"inputs\" was too long")
2883 }
2884
2885 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
2886 return err
2887 }
2888 if _, err := cw.WriteString(string("inputs")); err != nil {
2889 return err
2890 }
2891
2892 if len(t.Inputs) > 8192 {
2893 return xerrors.Errorf("Slice value in field t.Inputs was too long")
2894 }
2895
2896 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
2897 return err
2898 }
2899 for _, v := range t.Inputs {
2900 if err := v.MarshalCBOR(cw); err != nil {
2901 return err
2902 }
2903
2904 }
2905 }
2906 return nil
2907}
2908
2909func (t *Pipeline_ManualTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
2910 *t = Pipeline_ManualTriggerData{}
2911
2912 cr := cbg.NewCborReader(r)
2913
2914 maj, extra, err := cr.ReadHeader()
2915 if err != nil {
2916 return err
2917 }
2918 defer func() {
2919 if err == io.EOF {
2920 err = io.ErrUnexpectedEOF
2921 }
2922 }()
2923
2924 if maj != cbg.MajMap {
2925 return fmt.Errorf("cbor input should be of type map")
2926 }
2927
2928 if extra > cbg.MaxLength {
2929 return fmt.Errorf("Pipeline_ManualTriggerData: map struct too large (%d)", extra)
2930 }
2931
2932 n := extra
2933
2934 nameBuf := make([]byte, 6)
2935 for i := uint64(0); i < n; i++ {
2936 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2937 if err != nil {
2938 return err
2939 }
2940
2941 if !ok {
2942 // Field doesn't exist on this type, so ignore it
2943 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2944 return err
2945 }
2946 continue
2947 }
2948
2949 switch string(nameBuf[:nameLen]) {
2950 // t.Inputs ([]*tangled.Pipeline_Pair) (slice)
2951 case "inputs":
2952
2953 maj, extra, err = cr.ReadHeader()
2954 if err != nil {
2955 return err
2956 }
2957
2958 if extra > 8192 {
2959 return fmt.Errorf("t.Inputs: array too large (%d)", extra)
2960 }
2961
2962 if maj != cbg.MajArray {
2963 return fmt.Errorf("expected cbor array")
2964 }
2965
2966 if extra > 0 {
2967 t.Inputs = make([]*Pipeline_Pair, extra)
2968 }
2969
2970 for i := 0; i < int(extra); i++ {
2971 {
2972 var maj byte
2973 var extra uint64
2974 var err error
2975 _ = maj
2976 _ = extra
2977 _ = err
2978
2979 {
2980
2981 b, err := cr.ReadByte()
2982 if err != nil {
2983 return err
2984 }
2985 if b != cbg.CborNull[0] {
2986 if err := cr.UnreadByte(); err != nil {
2987 return err
2988 }
2989 t.Inputs[i] = new(Pipeline_Pair)
2990 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
2991 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
2992 }
2993 }
2994
2995 }
2996
2997 }
2998 }
2999
3000 default:
3001 // Field doesn't exist on this type, so ignore it
3002 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3003 return err
3004 }
3005 }
3006 }
3007
3008 return nil
3009}
3010func (t *Pipeline_Pair) MarshalCBOR(w io.Writer) error {
3011 if t == nil {
3012 _, err := w.Write(cbg.CborNull)
3013 return err
3014 }
3015
3016 cw := cbg.NewCborWriter(w)
3017
3018 if _, err := cw.Write([]byte{162}); err != nil {
3019 return err
3020 }
3021
3022 // t.Key (string) (string)
3023 if len("key") > 1000000 {
3024 return xerrors.Errorf("Value in field \"key\" was too long")
3025 }
3026
3027 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
3028 return err
3029 }
3030 if _, err := cw.WriteString(string("key")); err != nil {
3031 return err
3032 }
3033
3034 if len(t.Key) > 1000000 {
3035 return xerrors.Errorf("Value in field t.Key was too long")
3036 }
3037
3038 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
3039 return err
3040 }
3041 if _, err := cw.WriteString(string(t.Key)); err != nil {
3042 return err
3043 }
3044
3045 // t.Value (string) (string)
3046 if len("value") > 1000000 {
3047 return xerrors.Errorf("Value in field \"value\" was too long")
3048 }
3049
3050 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
3051 return err
3052 }
3053 if _, err := cw.WriteString(string("value")); err != nil {
3054 return err
3055 }
3056
3057 if len(t.Value) > 1000000 {
3058 return xerrors.Errorf("Value in field t.Value was too long")
3059 }
3060
3061 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
3062 return err
3063 }
3064 if _, err := cw.WriteString(string(t.Value)); err != nil {
3065 return err
3066 }
3067 return nil
3068}
3069
3070func (t *Pipeline_Pair) UnmarshalCBOR(r io.Reader) (err error) {
3071 *t = Pipeline_Pair{}
3072
3073 cr := cbg.NewCborReader(r)
3074
3075 maj, extra, err := cr.ReadHeader()
3076 if err != nil {
3077 return err
3078 }
3079 defer func() {
3080 if err == io.EOF {
3081 err = io.ErrUnexpectedEOF
3082 }
3083 }()
3084
3085 if maj != cbg.MajMap {
3086 return fmt.Errorf("cbor input should be of type map")
3087 }
3088
3089 if extra > cbg.MaxLength {
3090 return fmt.Errorf("Pipeline_Pair: map struct too large (%d)", extra)
3091 }
3092
3093 n := extra
3094
3095 nameBuf := make([]byte, 5)
3096 for i := uint64(0); i < n; i++ {
3097 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3098 if err != nil {
3099 return err
3100 }
3101
3102 if !ok {
3103 // Field doesn't exist on this type, so ignore it
3104 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3105 return err
3106 }
3107 continue
3108 }
3109
3110 switch string(nameBuf[:nameLen]) {
3111 // t.Key (string) (string)
3112 case "key":
3113
3114 {
3115 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3116 if err != nil {
3117 return err
3118 }
3119
3120 t.Key = string(sval)
3121 }
3122 // t.Value (string) (string)
3123 case "value":
3124
3125 {
3126 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3127 if err != nil {
3128 return err
3129 }
3130
3131 t.Value = string(sval)
3132 }
3133
3134 default:
3135 // Field doesn't exist on this type, so ignore it
3136 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3137 return err
3138 }
3139 }
3140 }
3141
3142 return nil
3143}
3144func (t *Pipeline_PullRequestTriggerData) MarshalCBOR(w io.Writer) error {
3145 if t == nil {
3146 _, err := w.Write(cbg.CborNull)
3147 return err
3148 }
3149
3150 cw := cbg.NewCborWriter(w)
3151
3152 if _, err := cw.Write([]byte{164}); err != nil {
3153 return err
3154 }
3155
3156 // t.Action (string) (string)
3157 if len("action") > 1000000 {
3158 return xerrors.Errorf("Value in field \"action\" was too long")
3159 }
3160
3161 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("action"))); err != nil {
3162 return err
3163 }
3164 if _, err := cw.WriteString(string("action")); err != nil {
3165 return err
3166 }
3167
3168 if len(t.Action) > 1000000 {
3169 return xerrors.Errorf("Value in field t.Action was too long")
3170 }
3171
3172 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Action))); err != nil {
3173 return err
3174 }
3175 if _, err := cw.WriteString(string(t.Action)); err != nil {
3176 return err
3177 }
3178
3179 // t.SourceSha (string) (string)
3180 if len("sourceSha") > 1000000 {
3181 return xerrors.Errorf("Value in field \"sourceSha\" was too long")
3182 }
3183
3184 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceSha"))); err != nil {
3185 return err
3186 }
3187 if _, err := cw.WriteString(string("sourceSha")); err != nil {
3188 return err
3189 }
3190
3191 if len(t.SourceSha) > 1000000 {
3192 return xerrors.Errorf("Value in field t.SourceSha was too long")
3193 }
3194
3195 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceSha))); err != nil {
3196 return err
3197 }
3198 if _, err := cw.WriteString(string(t.SourceSha)); err != nil {
3199 return err
3200 }
3201
3202 // t.SourceBranch (string) (string)
3203 if len("sourceBranch") > 1000000 {
3204 return xerrors.Errorf("Value in field \"sourceBranch\" was too long")
3205 }
3206
3207 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceBranch"))); err != nil {
3208 return err
3209 }
3210 if _, err := cw.WriteString(string("sourceBranch")); err != nil {
3211 return err
3212 }
3213
3214 if len(t.SourceBranch) > 1000000 {
3215 return xerrors.Errorf("Value in field t.SourceBranch was too long")
3216 }
3217
3218 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceBranch))); err != nil {
3219 return err
3220 }
3221 if _, err := cw.WriteString(string(t.SourceBranch)); err != nil {
3222 return err
3223 }
3224
3225 // t.TargetBranch (string) (string)
3226 if len("targetBranch") > 1000000 {
3227 return xerrors.Errorf("Value in field \"targetBranch\" was too long")
3228 }
3229
3230 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil {
3231 return err
3232 }
3233 if _, err := cw.WriteString(string("targetBranch")); err != nil {
3234 return err
3235 }
3236
3237 if len(t.TargetBranch) > 1000000 {
3238 return xerrors.Errorf("Value in field t.TargetBranch was too long")
3239 }
3240
3241 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil {
3242 return err
3243 }
3244 if _, err := cw.WriteString(string(t.TargetBranch)); err != nil {
3245 return err
3246 }
3247 return nil
3248}
3249
3250func (t *Pipeline_PullRequestTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
3251 *t = Pipeline_PullRequestTriggerData{}
3252
3253 cr := cbg.NewCborReader(r)
3254
3255 maj, extra, err := cr.ReadHeader()
3256 if err != nil {
3257 return err
3258 }
3259 defer func() {
3260 if err == io.EOF {
3261 err = io.ErrUnexpectedEOF
3262 }
3263 }()
3264
3265 if maj != cbg.MajMap {
3266 return fmt.Errorf("cbor input should be of type map")
3267 }
3268
3269 if extra > cbg.MaxLength {
3270 return fmt.Errorf("Pipeline_PullRequestTriggerData: map struct too large (%d)", extra)
3271 }
3272
3273 n := extra
3274
3275 nameBuf := make([]byte, 12)
3276 for i := uint64(0); i < n; i++ {
3277 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3278 if err != nil {
3279 return err
3280 }
3281
3282 if !ok {
3283 // Field doesn't exist on this type, so ignore it
3284 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3285 return err
3286 }
3287 continue
3288 }
3289
3290 switch string(nameBuf[:nameLen]) {
3291 // t.Action (string) (string)
3292 case "action":
3293
3294 {
3295 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3296 if err != nil {
3297 return err
3298 }
3299
3300 t.Action = string(sval)
3301 }
3302 // t.SourceSha (string) (string)
3303 case "sourceSha":
3304
3305 {
3306 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3307 if err != nil {
3308 return err
3309 }
3310
3311 t.SourceSha = string(sval)
3312 }
3313 // t.SourceBranch (string) (string)
3314 case "sourceBranch":
3315
3316 {
3317 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3318 if err != nil {
3319 return err
3320 }
3321
3322 t.SourceBranch = string(sval)
3323 }
3324 // t.TargetBranch (string) (string)
3325 case "targetBranch":
3326
3327 {
3328 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3329 if err != nil {
3330 return err
3331 }
3332
3333 t.TargetBranch = string(sval)
3334 }
3335
3336 default:
3337 // Field doesn't exist on this type, so ignore it
3338 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3339 return err
3340 }
3341 }
3342 }
3343
3344 return nil
3345}
3346func (t *Pipeline_PushTriggerData) MarshalCBOR(w io.Writer) error {
3347 if t == nil {
3348 _, err := w.Write(cbg.CborNull)
3349 return err
3350 }
3351
3352 cw := cbg.NewCborWriter(w)
3353
3354 if _, err := cw.Write([]byte{163}); err != nil {
3355 return err
3356 }
3357
3358 // t.Ref (string) (string)
3359 if len("ref") > 1000000 {
3360 return xerrors.Errorf("Value in field \"ref\" was too long")
3361 }
3362
3363 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
3364 return err
3365 }
3366 if _, err := cw.WriteString(string("ref")); err != nil {
3367 return err
3368 }
3369
3370 if len(t.Ref) > 1000000 {
3371 return xerrors.Errorf("Value in field t.Ref was too long")
3372 }
3373
3374 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
3375 return err
3376 }
3377 if _, err := cw.WriteString(string(t.Ref)); err != nil {
3378 return err
3379 }
3380
3381 // t.NewSha (string) (string)
3382 if len("newSha") > 1000000 {
3383 return xerrors.Errorf("Value in field \"newSha\" was too long")
3384 }
3385
3386 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
3387 return err
3388 }
3389 if _, err := cw.WriteString(string("newSha")); err != nil {
3390 return err
3391 }
3392
3393 if len(t.NewSha) > 1000000 {
3394 return xerrors.Errorf("Value in field t.NewSha was too long")
3395 }
3396
3397 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
3398 return err
3399 }
3400 if _, err := cw.WriteString(string(t.NewSha)); err != nil {
3401 return err
3402 }
3403
3404 // t.OldSha (string) (string)
3405 if len("oldSha") > 1000000 {
3406 return xerrors.Errorf("Value in field \"oldSha\" was too long")
3407 }
3408
3409 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
3410 return err
3411 }
3412 if _, err := cw.WriteString(string("oldSha")); err != nil {
3413 return err
3414 }
3415
3416 if len(t.OldSha) > 1000000 {
3417 return xerrors.Errorf("Value in field t.OldSha was too long")
3418 }
3419
3420 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
3421 return err
3422 }
3423 if _, err := cw.WriteString(string(t.OldSha)); err != nil {
3424 return err
3425 }
3426 return nil
3427}
3428
3429func (t *Pipeline_PushTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
3430 *t = Pipeline_PushTriggerData{}
3431
3432 cr := cbg.NewCborReader(r)
3433
3434 maj, extra, err := cr.ReadHeader()
3435 if err != nil {
3436 return err
3437 }
3438 defer func() {
3439 if err == io.EOF {
3440 err = io.ErrUnexpectedEOF
3441 }
3442 }()
3443
3444 if maj != cbg.MajMap {
3445 return fmt.Errorf("cbor input should be of type map")
3446 }
3447
3448 if extra > cbg.MaxLength {
3449 return fmt.Errorf("Pipeline_PushTriggerData: map struct too large (%d)", extra)
3450 }
3451
3452 n := extra
3453
3454 nameBuf := make([]byte, 6)
3455 for i := uint64(0); i < n; i++ {
3456 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3457 if err != nil {
3458 return err
3459 }
3460
3461 if !ok {
3462 // Field doesn't exist on this type, so ignore it
3463 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3464 return err
3465 }
3466 continue
3467 }
3468
3469 switch string(nameBuf[:nameLen]) {
3470 // t.Ref (string) (string)
3471 case "ref":
3472
3473 {
3474 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3475 if err != nil {
3476 return err
3477 }
3478
3479 t.Ref = string(sval)
3480 }
3481 // t.NewSha (string) (string)
3482 case "newSha":
3483
3484 {
3485 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3486 if err != nil {
3487 return err
3488 }
3489
3490 t.NewSha = string(sval)
3491 }
3492 // t.OldSha (string) (string)
3493 case "oldSha":
3494
3495 {
3496 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3497 if err != nil {
3498 return err
3499 }
3500
3501 t.OldSha = string(sval)
3502 }
3503
3504 default:
3505 // Field doesn't exist on this type, so ignore it
3506 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3507 return err
3508 }
3509 }
3510 }
3511
3512 return nil
3513}
3514func (t *PipelineStatus) MarshalCBOR(w io.Writer) error {
3515 if t == nil {
3516 _, err := w.Write(cbg.CborNull)
3517 return err
3518 }
3519
3520 cw := cbg.NewCborWriter(w)
3521 fieldCount := 7
3522
3523 if t.Error == nil {
3524 fieldCount--
3525 }
3526
3527 if t.ExitCode == nil {
3528 fieldCount--
3529 }
3530
3531 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3532 return err
3533 }
3534
3535 // t.LexiconTypeID (string) (string)
3536 if len("$type") > 1000000 {
3537 return xerrors.Errorf("Value in field \"$type\" was too long")
3538 }
3539
3540 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3541 return err
3542 }
3543 if _, err := cw.WriteString(string("$type")); err != nil {
3544 return err
3545 }
3546
3547 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline.status"))); err != nil {
3548 return err
3549 }
3550 if _, err := cw.WriteString(string("sh.tangled.pipeline.status")); err != nil {
3551 return err
3552 }
3553
3554 // t.Error (string) (string)
3555 if t.Error != nil {
3556
3557 if len("error") > 1000000 {
3558 return xerrors.Errorf("Value in field \"error\" was too long")
3559 }
3560
3561 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("error"))); err != nil {
3562 return err
3563 }
3564 if _, err := cw.WriteString(string("error")); err != nil {
3565 return err
3566 }
3567
3568 if t.Error == nil {
3569 if _, err := cw.Write(cbg.CborNull); err != nil {
3570 return err
3571 }
3572 } else {
3573 if len(*t.Error) > 1000000 {
3574 return xerrors.Errorf("Value in field t.Error was too long")
3575 }
3576
3577 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Error))); err != nil {
3578 return err
3579 }
3580 if _, err := cw.WriteString(string(*t.Error)); err != nil {
3581 return err
3582 }
3583 }
3584 }
3585
3586 // t.Status (string) (string)
3587 if len("status") > 1000000 {
3588 return xerrors.Errorf("Value in field \"status\" was too long")
3589 }
3590
3591 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
3592 return err
3593 }
3594 if _, err := cw.WriteString(string("status")); err != nil {
3595 return err
3596 }
3597
3598 if len(t.Status) > 1000000 {
3599 return xerrors.Errorf("Value in field t.Status was too long")
3600 }
3601
3602 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
3603 return err
3604 }
3605 if _, err := cw.WriteString(string(t.Status)); err != nil {
3606 return err
3607 }
3608
3609 // t.ExitCode (int64) (int64)
3610 if t.ExitCode != nil {
3611
3612 if len("exitCode") > 1000000 {
3613 return xerrors.Errorf("Value in field \"exitCode\" was too long")
3614 }
3615
3616 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("exitCode"))); err != nil {
3617 return err
3618 }
3619 if _, err := cw.WriteString(string("exitCode")); err != nil {
3620 return err
3621 }
3622
3623 if t.ExitCode == nil {
3624 if _, err := cw.Write(cbg.CborNull); err != nil {
3625 return err
3626 }
3627 } else {
3628 if *t.ExitCode >= 0 {
3629 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.ExitCode)); err != nil {
3630 return err
3631 }
3632 } else {
3633 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.ExitCode-1)); err != nil {
3634 return err
3635 }
3636 }
3637 }
3638
3639 }
3640
3641 // t.Pipeline (string) (string)
3642 if len("pipeline") > 1000000 {
3643 return xerrors.Errorf("Value in field \"pipeline\" was too long")
3644 }
3645
3646 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pipeline"))); err != nil {
3647 return err
3648 }
3649 if _, err := cw.WriteString(string("pipeline")); err != nil {
3650 return err
3651 }
3652
3653 if len(t.Pipeline) > 1000000 {
3654 return xerrors.Errorf("Value in field t.Pipeline was too long")
3655 }
3656
3657 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pipeline))); err != nil {
3658 return err
3659 }
3660 if _, err := cw.WriteString(string(t.Pipeline)); err != nil {
3661 return err
3662 }
3663
3664 // t.Workflow (string) (string)
3665 if len("workflow") > 1000000 {
3666 return xerrors.Errorf("Value in field \"workflow\" was too long")
3667 }
3668
3669 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil {
3670 return err
3671 }
3672 if _, err := cw.WriteString(string("workflow")); err != nil {
3673 return err
3674 }
3675
3676 if len(t.Workflow) > 1000000 {
3677 return xerrors.Errorf("Value in field t.Workflow was too long")
3678 }
3679
3680 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil {
3681 return err
3682 }
3683 if _, err := cw.WriteString(string(t.Workflow)); err != nil {
3684 return err
3685 }
3686
3687 // t.CreatedAt (string) (string)
3688 if len("createdAt") > 1000000 {
3689 return xerrors.Errorf("Value in field \"createdAt\" was too long")
3690 }
3691
3692 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
3693 return err
3694 }
3695 if _, err := cw.WriteString(string("createdAt")); err != nil {
3696 return err
3697 }
3698
3699 if len(t.CreatedAt) > 1000000 {
3700 return xerrors.Errorf("Value in field t.CreatedAt was too long")
3701 }
3702
3703 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
3704 return err
3705 }
3706 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
3707 return err
3708 }
3709 return nil
3710}
3711
3712func (t *PipelineStatus) UnmarshalCBOR(r io.Reader) (err error) {
3713 *t = PipelineStatus{}
3714
3715 cr := cbg.NewCborReader(r)
3716
3717 maj, extra, err := cr.ReadHeader()
3718 if err != nil {
3719 return err
3720 }
3721 defer func() {
3722 if err == io.EOF {
3723 err = io.ErrUnexpectedEOF
3724 }
3725 }()
3726
3727 if maj != cbg.MajMap {
3728 return fmt.Errorf("cbor input should be of type map")
3729 }
3730
3731 if extra > cbg.MaxLength {
3732 return fmt.Errorf("PipelineStatus: map struct too large (%d)", extra)
3733 }
3734
3735 n := extra
3736
3737 nameBuf := make([]byte, 9)
3738 for i := uint64(0); i < n; i++ {
3739 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3740 if err != nil {
3741 return err
3742 }
3743
3744 if !ok {
3745 // Field doesn't exist on this type, so ignore it
3746 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3747 return err
3748 }
3749 continue
3750 }
3751
3752 switch string(nameBuf[:nameLen]) {
3753 // t.LexiconTypeID (string) (string)
3754 case "$type":
3755
3756 {
3757 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3758 if err != nil {
3759 return err
3760 }
3761
3762 t.LexiconTypeID = string(sval)
3763 }
3764 // t.Error (string) (string)
3765 case "error":
3766
3767 {
3768 b, err := cr.ReadByte()
3769 if err != nil {
3770 return err
3771 }
3772 if b != cbg.CborNull[0] {
3773 if err := cr.UnreadByte(); err != nil {
3774 return err
3775 }
3776
3777 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3778 if err != nil {
3779 return err
3780 }
3781
3782 t.Error = (*string)(&sval)
3783 }
3784 }
3785 // t.Status (string) (string)
3786 case "status":
3787
3788 {
3789 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3790 if err != nil {
3791 return err
3792 }
3793
3794 t.Status = string(sval)
3795 }
3796 // t.ExitCode (int64) (int64)
3797 case "exitCode":
3798 {
3799
3800 b, err := cr.ReadByte()
3801 if err != nil {
3802 return err
3803 }
3804 if b != cbg.CborNull[0] {
3805 if err := cr.UnreadByte(); err != nil {
3806 return err
3807 }
3808 maj, extra, err := cr.ReadHeader()
3809 if err != nil {
3810 return err
3811 }
3812 var extraI int64
3813 switch maj {
3814 case cbg.MajUnsignedInt:
3815 extraI = int64(extra)
3816 if extraI < 0 {
3817 return fmt.Errorf("int64 positive overflow")
3818 }
3819 case cbg.MajNegativeInt:
3820 extraI = int64(extra)
3821 if extraI < 0 {
3822 return fmt.Errorf("int64 negative overflow")
3823 }
3824 extraI = -1 - extraI
3825 default:
3826 return fmt.Errorf("wrong type for int64 field: %d", maj)
3827 }
3828
3829 t.ExitCode = (*int64)(&extraI)
3830 }
3831 }
3832 // t.Pipeline (string) (string)
3833 case "pipeline":
3834
3835 {
3836 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3837 if err != nil {
3838 return err
3839 }
3840
3841 t.Pipeline = string(sval)
3842 }
3843 // t.Workflow (string) (string)
3844 case "workflow":
3845
3846 {
3847 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3848 if err != nil {
3849 return err
3850 }
3851
3852 t.Workflow = string(sval)
3853 }
3854 // t.CreatedAt (string) (string)
3855 case "createdAt":
3856
3857 {
3858 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3859 if err != nil {
3860 return err
3861 }
3862
3863 t.CreatedAt = string(sval)
3864 }
3865
3866 default:
3867 // Field doesn't exist on this type, so ignore it
3868 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3869 return err
3870 }
3871 }
3872 }
3873
3874 return nil
3875}
3876func (t *Pipeline_TriggerMetadata) MarshalCBOR(w io.Writer) error {
3877 if t == nil {
3878 _, err := w.Write(cbg.CborNull)
3879 return err
3880 }
3881
3882 cw := cbg.NewCborWriter(w)
3883 fieldCount := 5
3884
3885 if t.Manual == nil {
3886 fieldCount--
3887 }
3888
3889 if t.PullRequest == nil {
3890 fieldCount--
3891 }
3892
3893 if t.Push == nil {
3894 fieldCount--
3895 }
3896
3897 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3898 return err
3899 }
3900
3901 // t.Kind (string) (string)
3902 if len("kind") > 1000000 {
3903 return xerrors.Errorf("Value in field \"kind\" was too long")
3904 }
3905
3906 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("kind"))); err != nil {
3907 return err
3908 }
3909 if _, err := cw.WriteString(string("kind")); err != nil {
3910 return err
3911 }
3912
3913 if len(t.Kind) > 1000000 {
3914 return xerrors.Errorf("Value in field t.Kind was too long")
3915 }
3916
3917 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Kind))); err != nil {
3918 return err
3919 }
3920 if _, err := cw.WriteString(string(t.Kind)); err != nil {
3921 return err
3922 }
3923
3924 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
3925 if t.Push != nil {
3926
3927 if len("push") > 1000000 {
3928 return xerrors.Errorf("Value in field \"push\" was too long")
3929 }
3930
3931 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("push"))); err != nil {
3932 return err
3933 }
3934 if _, err := cw.WriteString(string("push")); err != nil {
3935 return err
3936 }
3937
3938 if err := t.Push.MarshalCBOR(cw); err != nil {
3939 return err
3940 }
3941 }
3942
3943 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
3944 if len("repo") > 1000000 {
3945 return xerrors.Errorf("Value in field \"repo\" was too long")
3946 }
3947
3948 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
3949 return err
3950 }
3951 if _, err := cw.WriteString(string("repo")); err != nil {
3952 return err
3953 }
3954
3955 if err := t.Repo.MarshalCBOR(cw); err != nil {
3956 return err
3957 }
3958
3959 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
3960 if t.Manual != nil {
3961
3962 if len("manual") > 1000000 {
3963 return xerrors.Errorf("Value in field \"manual\" was too long")
3964 }
3965
3966 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("manual"))); err != nil {
3967 return err
3968 }
3969 if _, err := cw.WriteString(string("manual")); err != nil {
3970 return err
3971 }
3972
3973 if err := t.Manual.MarshalCBOR(cw); err != nil {
3974 return err
3975 }
3976 }
3977
3978 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
3979 if t.PullRequest != nil {
3980
3981 if len("pullRequest") > 1000000 {
3982 return xerrors.Errorf("Value in field \"pullRequest\" was too long")
3983 }
3984
3985 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullRequest"))); err != nil {
3986 return err
3987 }
3988 if _, err := cw.WriteString(string("pullRequest")); err != nil {
3989 return err
3990 }
3991
3992 if err := t.PullRequest.MarshalCBOR(cw); err != nil {
3993 return err
3994 }
3995 }
3996 return nil
3997}
3998
3999func (t *Pipeline_TriggerMetadata) UnmarshalCBOR(r io.Reader) (err error) {
4000 *t = Pipeline_TriggerMetadata{}
4001
4002 cr := cbg.NewCborReader(r)
4003
4004 maj, extra, err := cr.ReadHeader()
4005 if err != nil {
4006 return err
4007 }
4008 defer func() {
4009 if err == io.EOF {
4010 err = io.ErrUnexpectedEOF
4011 }
4012 }()
4013
4014 if maj != cbg.MajMap {
4015 return fmt.Errorf("cbor input should be of type map")
4016 }
4017
4018 if extra > cbg.MaxLength {
4019 return fmt.Errorf("Pipeline_TriggerMetadata: map struct too large (%d)", extra)
4020 }
4021
4022 n := extra
4023
4024 nameBuf := make([]byte, 11)
4025 for i := uint64(0); i < n; i++ {
4026 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4027 if err != nil {
4028 return err
4029 }
4030
4031 if !ok {
4032 // Field doesn't exist on this type, so ignore it
4033 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4034 return err
4035 }
4036 continue
4037 }
4038
4039 switch string(nameBuf[:nameLen]) {
4040 // t.Kind (string) (string)
4041 case "kind":
4042
4043 {
4044 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4045 if err != nil {
4046 return err
4047 }
4048
4049 t.Kind = string(sval)
4050 }
4051 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
4052 case "push":
4053
4054 {
4055
4056 b, err := cr.ReadByte()
4057 if err != nil {
4058 return err
4059 }
4060 if b != cbg.CborNull[0] {
4061 if err := cr.UnreadByte(); err != nil {
4062 return err
4063 }
4064 t.Push = new(Pipeline_PushTriggerData)
4065 if err := t.Push.UnmarshalCBOR(cr); err != nil {
4066 return xerrors.Errorf("unmarshaling t.Push pointer: %w", err)
4067 }
4068 }
4069
4070 }
4071 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
4072 case "repo":
4073
4074 {
4075
4076 b, err := cr.ReadByte()
4077 if err != nil {
4078 return err
4079 }
4080 if b != cbg.CborNull[0] {
4081 if err := cr.UnreadByte(); err != nil {
4082 return err
4083 }
4084 t.Repo = new(Pipeline_TriggerRepo)
4085 if err := t.Repo.UnmarshalCBOR(cr); err != nil {
4086 return xerrors.Errorf("unmarshaling t.Repo pointer: %w", err)
4087 }
4088 }
4089
4090 }
4091 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
4092 case "manual":
4093
4094 {
4095
4096 b, err := cr.ReadByte()
4097 if err != nil {
4098 return err
4099 }
4100 if b != cbg.CborNull[0] {
4101 if err := cr.UnreadByte(); err != nil {
4102 return err
4103 }
4104 t.Manual = new(Pipeline_ManualTriggerData)
4105 if err := t.Manual.UnmarshalCBOR(cr); err != nil {
4106 return xerrors.Errorf("unmarshaling t.Manual pointer: %w", err)
4107 }
4108 }
4109
4110 }
4111 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
4112 case "pullRequest":
4113
4114 {
4115
4116 b, err := cr.ReadByte()
4117 if err != nil {
4118 return err
4119 }
4120 if b != cbg.CborNull[0] {
4121 if err := cr.UnreadByte(); err != nil {
4122 return err
4123 }
4124 t.PullRequest = new(Pipeline_PullRequestTriggerData)
4125 if err := t.PullRequest.UnmarshalCBOR(cr); err != nil {
4126 return xerrors.Errorf("unmarshaling t.PullRequest pointer: %w", err)
4127 }
4128 }
4129
4130 }
4131
4132 default:
4133 // Field doesn't exist on this type, so ignore it
4134 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4135 return err
4136 }
4137 }
4138 }
4139
4140 return nil
4141}
4142func (t *Pipeline_TriggerRepo) MarshalCBOR(w io.Writer) error {
4143 if t == nil {
4144 _, err := w.Write(cbg.CborNull)
4145 return err
4146 }
4147
4148 cw := cbg.NewCborWriter(w)
4149
4150 if _, err := cw.Write([]byte{164}); err != nil {
4151 return err
4152 }
4153
4154 // t.Did (string) (string)
4155 if len("did") > 1000000 {
4156 return xerrors.Errorf("Value in field \"did\" was too long")
4157 }
4158
4159 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil {
4160 return err
4161 }
4162 if _, err := cw.WriteString(string("did")); err != nil {
4163 return err
4164 }
4165
4166 if len(t.Did) > 1000000 {
4167 return xerrors.Errorf("Value in field t.Did was too long")
4168 }
4169
4170 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil {
4171 return err
4172 }
4173 if _, err := cw.WriteString(string(t.Did)); err != nil {
4174 return err
4175 }
4176
4177 // t.Knot (string) (string)
4178 if len("knot") > 1000000 {
4179 return xerrors.Errorf("Value in field \"knot\" was too long")
4180 }
4181
4182 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
4183 return err
4184 }
4185 if _, err := cw.WriteString(string("knot")); err != nil {
4186 return err
4187 }
4188
4189 if len(t.Knot) > 1000000 {
4190 return xerrors.Errorf("Value in field t.Knot was too long")
4191 }
4192
4193 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
4194 return err
4195 }
4196 if _, err := cw.WriteString(string(t.Knot)); err != nil {
4197 return err
4198 }
4199
4200 // t.Repo (string) (string)
4201 if len("repo") > 1000000 {
4202 return xerrors.Errorf("Value in field \"repo\" was too long")
4203 }
4204
4205 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
4206 return err
4207 }
4208 if _, err := cw.WriteString(string("repo")); err != nil {
4209 return err
4210 }
4211
4212 if len(t.Repo) > 1000000 {
4213 return xerrors.Errorf("Value in field t.Repo was too long")
4214 }
4215
4216 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
4217 return err
4218 }
4219 if _, err := cw.WriteString(string(t.Repo)); err != nil {
4220 return err
4221 }
4222
4223 // t.DefaultBranch (string) (string)
4224 if len("defaultBranch") > 1000000 {
4225 return xerrors.Errorf("Value in field \"defaultBranch\" was too long")
4226 }
4227
4228 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("defaultBranch"))); err != nil {
4229 return err
4230 }
4231 if _, err := cw.WriteString(string("defaultBranch")); err != nil {
4232 return err
4233 }
4234
4235 if len(t.DefaultBranch) > 1000000 {
4236 return xerrors.Errorf("Value in field t.DefaultBranch was too long")
4237 }
4238
4239 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.DefaultBranch))); err != nil {
4240 return err
4241 }
4242 if _, err := cw.WriteString(string(t.DefaultBranch)); err != nil {
4243 return err
4244 }
4245 return nil
4246}
4247
4248func (t *Pipeline_TriggerRepo) UnmarshalCBOR(r io.Reader) (err error) {
4249 *t = Pipeline_TriggerRepo{}
4250
4251 cr := cbg.NewCborReader(r)
4252
4253 maj, extra, err := cr.ReadHeader()
4254 if err != nil {
4255 return err
4256 }
4257 defer func() {
4258 if err == io.EOF {
4259 err = io.ErrUnexpectedEOF
4260 }
4261 }()
4262
4263 if maj != cbg.MajMap {
4264 return fmt.Errorf("cbor input should be of type map")
4265 }
4266
4267 if extra > cbg.MaxLength {
4268 return fmt.Errorf("Pipeline_TriggerRepo: map struct too large (%d)", extra)
4269 }
4270
4271 n := extra
4272
4273 nameBuf := make([]byte, 13)
4274 for i := uint64(0); i < n; i++ {
4275 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4276 if err != nil {
4277 return err
4278 }
4279
4280 if !ok {
4281 // Field doesn't exist on this type, so ignore it
4282 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4283 return err
4284 }
4285 continue
4286 }
4287
4288 switch string(nameBuf[:nameLen]) {
4289 // t.Did (string) (string)
4290 case "did":
4291
4292 {
4293 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4294 if err != nil {
4295 return err
4296 }
4297
4298 t.Did = string(sval)
4299 }
4300 // t.Knot (string) (string)
4301 case "knot":
4302
4303 {
4304 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4305 if err != nil {
4306 return err
4307 }
4308
4309 t.Knot = string(sval)
4310 }
4311 // t.Repo (string) (string)
4312 case "repo":
4313
4314 {
4315 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4316 if err != nil {
4317 return err
4318 }
4319
4320 t.Repo = string(sval)
4321 }
4322 // t.DefaultBranch (string) (string)
4323 case "defaultBranch":
4324
4325 {
4326 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4327 if err != nil {
4328 return err
4329 }
4330
4331 t.DefaultBranch = string(sval)
4332 }
4333
4334 default:
4335 // Field doesn't exist on this type, so ignore it
4336 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4337 return err
4338 }
4339 }
4340 }
4341
4342 return nil
4343}
4344func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error {
4345 if t == nil {
4346 _, err := w.Write(cbg.CborNull)
4347 return err
4348 }
4349
4350 cw := cbg.NewCborWriter(w)
4351
4352 if _, err := cw.Write([]byte{164}); err != nil {
4353 return err
4354 }
4355
4356 // t.Raw (string) (string)
4357 if len("raw") > 1000000 {
4358 return xerrors.Errorf("Value in field \"raw\" was too long")
4359 }
4360
4361 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("raw"))); err != nil {
4362 return err
4363 }
4364 if _, err := cw.WriteString(string("raw")); err != nil {
4365 return err
4366 }
4367
4368 if len(t.Raw) > 1000000 {
4369 return xerrors.Errorf("Value in field t.Raw was too long")
4370 }
4371
4372 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Raw))); err != nil {
4373 return err
4374 }
4375 if _, err := cw.WriteString(string(t.Raw)); err != nil {
4376 return err
4377 }
4378
4379 // t.Name (string) (string)
4380 if len("name") > 1000000 {
4381 return xerrors.Errorf("Value in field \"name\" was too long")
4382 }
4383
4384 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
4385 return err
4386 }
4387 if _, err := cw.WriteString(string("name")); err != nil {
4388 return err
4389 }
4390
4391 if len(t.Name) > 1000000 {
4392 return xerrors.Errorf("Value in field t.Name was too long")
4393 }
4394
4395 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
4396 return err
4397 }
4398 if _, err := cw.WriteString(string(t.Name)); err != nil {
4399 return err
4400 }
4401
4402 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
4403 if len("clone") > 1000000 {
4404 return xerrors.Errorf("Value in field \"clone\" was too long")
4405 }
4406
4407 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil {
4408 return err
4409 }
4410 if _, err := cw.WriteString(string("clone")); err != nil {
4411 return err
4412 }
4413
4414 if err := t.Clone.MarshalCBOR(cw); err != nil {
4415 return err
4416 }
4417
4418 // t.Engine (string) (string)
4419 if len("engine") > 1000000 {
4420 return xerrors.Errorf("Value in field \"engine\" was too long")
4421 }
4422
4423 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("engine"))); err != nil {
4424 return err
4425 }
4426 if _, err := cw.WriteString(string("engine")); err != nil {
4427 return err
4428 }
4429
4430 if len(t.Engine) > 1000000 {
4431 return xerrors.Errorf("Value in field t.Engine was too long")
4432 }
4433
4434 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Engine))); err != nil {
4435 return err
4436 }
4437 if _, err := cw.WriteString(string(t.Engine)); err != nil {
4438 return err
4439 }
4440 return nil
4441}
4442
4443func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) {
4444 *t = Pipeline_Workflow{}
4445
4446 cr := cbg.NewCborReader(r)
4447
4448 maj, extra, err := cr.ReadHeader()
4449 if err != nil {
4450 return err
4451 }
4452 defer func() {
4453 if err == io.EOF {
4454 err = io.ErrUnexpectedEOF
4455 }
4456 }()
4457
4458 if maj != cbg.MajMap {
4459 return fmt.Errorf("cbor input should be of type map")
4460 }
4461
4462 if extra > cbg.MaxLength {
4463 return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra)
4464 }
4465
4466 n := extra
4467
4468 nameBuf := make([]byte, 6)
4469 for i := uint64(0); i < n; i++ {
4470 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4471 if err != nil {
4472 return err
4473 }
4474
4475 if !ok {
4476 // Field doesn't exist on this type, so ignore it
4477 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4478 return err
4479 }
4480 continue
4481 }
4482
4483 switch string(nameBuf[:nameLen]) {
4484 // t.Raw (string) (string)
4485 case "raw":
4486
4487 {
4488 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4489 if err != nil {
4490 return err
4491 }
4492
4493 t.Raw = string(sval)
4494 }
4495 // t.Name (string) (string)
4496 case "name":
4497
4498 {
4499 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4500 if err != nil {
4501 return err
4502 }
4503
4504 t.Name = string(sval)
4505 }
4506 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
4507 case "clone":
4508
4509 {
4510
4511 b, err := cr.ReadByte()
4512 if err != nil {
4513 return err
4514 }
4515 if b != cbg.CborNull[0] {
4516 if err := cr.UnreadByte(); err != nil {
4517 return err
4518 }
4519 t.Clone = new(Pipeline_CloneOpts)
4520 if err := t.Clone.UnmarshalCBOR(cr); err != nil {
4521 return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err)
4522 }
4523 }
4524
4525 }
4526 // t.Engine (string) (string)
4527 case "engine":
4528
4529 {
4530 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4531 if err != nil {
4532 return err
4533 }
4534
4535 t.Engine = string(sval)
4536 }
4537
4538 default:
4539 // Field doesn't exist on this type, so ignore it
4540 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4541 return err
4542 }
4543 }
4544 }
4545
4546 return nil
4547}
4548func (t *PublicKey) MarshalCBOR(w io.Writer) error {
4549 if t == nil {
4550 _, err := w.Write(cbg.CborNull)
4551 return err
4552 }
4553
4554 cw := cbg.NewCborWriter(w)
4555
4556 if _, err := cw.Write([]byte{164}); err != nil {
4557 return err
4558 }
4559
4560 // t.Key (string) (string)
4561 if len("key") > 1000000 {
4562 return xerrors.Errorf("Value in field \"key\" was too long")
4563 }
4564
4565 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
4566 return err
4567 }
4568 if _, err := cw.WriteString(string("key")); err != nil {
4569 return err
4570 }
4571
4572 if len(t.Key) > 1000000 {
4573 return xerrors.Errorf("Value in field t.Key was too long")
4574 }
4575
4576 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
4577 return err
4578 }
4579 if _, err := cw.WriteString(string(t.Key)); err != nil {
4580 return err
4581 }
4582
4583 // t.Name (string) (string)
4584 if len("name") > 1000000 {
4585 return xerrors.Errorf("Value in field \"name\" was too long")
4586 }
4587
4588 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
4589 return err
4590 }
4591 if _, err := cw.WriteString(string("name")); err != nil {
4592 return err
4593 }
4594
4595 if len(t.Name) > 1000000 {
4596 return xerrors.Errorf("Value in field t.Name was too long")
4597 }
4598
4599 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
4600 return err
4601 }
4602 if _, err := cw.WriteString(string(t.Name)); err != nil {
4603 return err
4604 }
4605
4606 // t.LexiconTypeID (string) (string)
4607 if len("$type") > 1000000 {
4608 return xerrors.Errorf("Value in field \"$type\" was too long")
4609 }
4610
4611 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
4612 return err
4613 }
4614 if _, err := cw.WriteString(string("$type")); err != nil {
4615 return err
4616 }
4617
4618 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil {
4619 return err
4620 }
4621 if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil {
4622 return err
4623 }
4624
4625 // t.CreatedAt (string) (string)
4626 if len("createdAt") > 1000000 {
4627 return xerrors.Errorf("Value in field \"createdAt\" was too long")
4628 }
4629
4630 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
4631 return err
4632 }
4633 if _, err := cw.WriteString(string("createdAt")); err != nil {
4634 return err
4635 }
4636
4637 if len(t.CreatedAt) > 1000000 {
4638 return xerrors.Errorf("Value in field t.CreatedAt was too long")
4639 }
4640
4641 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
4642 return err
4643 }
4644 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
4645 return err
4646 }
4647 return nil
4648}
4649
4650func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) {
4651 *t = PublicKey{}
4652
4653 cr := cbg.NewCborReader(r)
4654
4655 maj, extra, err := cr.ReadHeader()
4656 if err != nil {
4657 return err
4658 }
4659 defer func() {
4660 if err == io.EOF {
4661 err = io.ErrUnexpectedEOF
4662 }
4663 }()
4664
4665 if maj != cbg.MajMap {
4666 return fmt.Errorf("cbor input should be of type map")
4667 }
4668
4669 if extra > cbg.MaxLength {
4670 return fmt.Errorf("PublicKey: map struct too large (%d)", extra)
4671 }
4672
4673 n := extra
4674
4675 nameBuf := make([]byte, 9)
4676 for i := uint64(0); i < n; i++ {
4677 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4678 if err != nil {
4679 return err
4680 }
4681
4682 if !ok {
4683 // Field doesn't exist on this type, so ignore it
4684 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4685 return err
4686 }
4687 continue
4688 }
4689
4690 switch string(nameBuf[:nameLen]) {
4691 // t.Key (string) (string)
4692 case "key":
4693
4694 {
4695 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4696 if err != nil {
4697 return err
4698 }
4699
4700 t.Key = string(sval)
4701 }
4702 // t.Name (string) (string)
4703 case "name":
4704
4705 {
4706 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4707 if err != nil {
4708 return err
4709 }
4710
4711 t.Name = string(sval)
4712 }
4713 // t.LexiconTypeID (string) (string)
4714 case "$type":
4715
4716 {
4717 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4718 if err != nil {
4719 return err
4720 }
4721
4722 t.LexiconTypeID = string(sval)
4723 }
4724 // t.CreatedAt (string) (string)
4725 case "createdAt":
4726
4727 {
4728 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4729 if err != nil {
4730 return err
4731 }
4732
4733 t.CreatedAt = string(sval)
4734 }
4735
4736 default:
4737 // Field doesn't exist on this type, so ignore it
4738 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4739 return err
4740 }
4741 }
4742 }
4743
4744 return nil
4745}
4746func (t *Repo) MarshalCBOR(w io.Writer) error {
4747 if t == nil {
4748 _, err := w.Write(cbg.CborNull)
4749 return err
4750 }
4751
4752 cw := cbg.NewCborWriter(w)
4753 fieldCount := 8
4754
4755 if t.Description == nil {
4756 fieldCount--
4757 }
4758
4759 if t.Source == nil {
4760 fieldCount--
4761 }
4762
4763 if t.Spindle == nil {
4764 fieldCount--
4765 }
4766
4767 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4768 return err
4769 }
4770
4771 // t.Knot (string) (string)
4772 if len("knot") > 1000000 {
4773 return xerrors.Errorf("Value in field \"knot\" was too long")
4774 }
4775
4776 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
4777 return err
4778 }
4779 if _, err := cw.WriteString(string("knot")); err != nil {
4780 return err
4781 }
4782
4783 if len(t.Knot) > 1000000 {
4784 return xerrors.Errorf("Value in field t.Knot was too long")
4785 }
4786
4787 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
4788 return err
4789 }
4790 if _, err := cw.WriteString(string(t.Knot)); err != nil {
4791 return err
4792 }
4793
4794 // t.Name (string) (string)
4795 if len("name") > 1000000 {
4796 return xerrors.Errorf("Value in field \"name\" was too long")
4797 }
4798
4799 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
4800 return err
4801 }
4802 if _, err := cw.WriteString(string("name")); err != nil {
4803 return err
4804 }
4805
4806 if len(t.Name) > 1000000 {
4807 return xerrors.Errorf("Value in field t.Name was too long")
4808 }
4809
4810 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
4811 return err
4812 }
4813 if _, err := cw.WriteString(string(t.Name)); err != nil {
4814 return err
4815 }
4816
4817 // t.LexiconTypeID (string) (string)
4818 if len("$type") > 1000000 {
4819 return xerrors.Errorf("Value in field \"$type\" was too long")
4820 }
4821
4822 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
4823 return err
4824 }
4825 if _, err := cw.WriteString(string("$type")); err != nil {
4826 return err
4827 }
4828
4829 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil {
4830 return err
4831 }
4832 if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil {
4833 return err
4834 }
4835
4836 // t.Owner (string) (string)
4837 if len("owner") > 1000000 {
4838 return xerrors.Errorf("Value in field \"owner\" was too long")
4839 }
4840
4841 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
4842 return err
4843 }
4844 if _, err := cw.WriteString(string("owner")); err != nil {
4845 return err
4846 }
4847
4848 if len(t.Owner) > 1000000 {
4849 return xerrors.Errorf("Value in field t.Owner was too long")
4850 }
4851
4852 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {
4853 return err
4854 }
4855 if _, err := cw.WriteString(string(t.Owner)); err != nil {
4856 return err
4857 }
4858
4859 // t.Source (string) (string)
4860 if t.Source != nil {
4861
4862 if len("source") > 1000000 {
4863 return xerrors.Errorf("Value in field \"source\" was too long")
4864 }
4865
4866 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
4867 return err
4868 }
4869 if _, err := cw.WriteString(string("source")); err != nil {
4870 return err
4871 }
4872
4873 if t.Source == nil {
4874 if _, err := cw.Write(cbg.CborNull); err != nil {
4875 return err
4876 }
4877 } else {
4878 if len(*t.Source) > 1000000 {
4879 return xerrors.Errorf("Value in field t.Source was too long")
4880 }
4881
4882 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil {
4883 return err
4884 }
4885 if _, err := cw.WriteString(string(*t.Source)); err != nil {
4886 return err
4887 }
4888 }
4889 }
4890
4891 // t.Spindle (string) (string)
4892 if t.Spindle != nil {
4893
4894 if len("spindle") > 1000000 {
4895 return xerrors.Errorf("Value in field \"spindle\" was too long")
4896 }
4897
4898 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("spindle"))); err != nil {
4899 return err
4900 }
4901 if _, err := cw.WriteString(string("spindle")); err != nil {
4902 return err
4903 }
4904
4905 if t.Spindle == nil {
4906 if _, err := cw.Write(cbg.CborNull); err != nil {
4907 return err
4908 }
4909 } else {
4910 if len(*t.Spindle) > 1000000 {
4911 return xerrors.Errorf("Value in field t.Spindle was too long")
4912 }
4913
4914 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Spindle))); err != nil {
4915 return err
4916 }
4917 if _, err := cw.WriteString(string(*t.Spindle)); err != nil {
4918 return err
4919 }
4920 }
4921 }
4922
4923 // t.CreatedAt (string) (string)
4924 if len("createdAt") > 1000000 {
4925 return xerrors.Errorf("Value in field \"createdAt\" was too long")
4926 }
4927
4928 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
4929 return err
4930 }
4931 if _, err := cw.WriteString(string("createdAt")); err != nil {
4932 return err
4933 }
4934
4935 if len(t.CreatedAt) > 1000000 {
4936 return xerrors.Errorf("Value in field t.CreatedAt was too long")
4937 }
4938
4939 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
4940 return err
4941 }
4942 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
4943 return err
4944 }
4945
4946 // t.Description (string) (string)
4947 if t.Description != nil {
4948
4949 if len("description") > 1000000 {
4950 return xerrors.Errorf("Value in field \"description\" was too long")
4951 }
4952
4953 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
4954 return err
4955 }
4956 if _, err := cw.WriteString(string("description")); err != nil {
4957 return err
4958 }
4959
4960 if t.Description == nil {
4961 if _, err := cw.Write(cbg.CborNull); err != nil {
4962 return err
4963 }
4964 } else {
4965 if len(*t.Description) > 1000000 {
4966 return xerrors.Errorf("Value in field t.Description was too long")
4967 }
4968
4969 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
4970 return err
4971 }
4972 if _, err := cw.WriteString(string(*t.Description)); err != nil {
4973 return err
4974 }
4975 }
4976 }
4977 return nil
4978}
4979
4980func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) {
4981 *t = Repo{}
4982
4983 cr := cbg.NewCborReader(r)
4984
4985 maj, extra, err := cr.ReadHeader()
4986 if err != nil {
4987 return err
4988 }
4989 defer func() {
4990 if err == io.EOF {
4991 err = io.ErrUnexpectedEOF
4992 }
4993 }()
4994
4995 if maj != cbg.MajMap {
4996 return fmt.Errorf("cbor input should be of type map")
4997 }
4998
4999 if extra > cbg.MaxLength {
5000 return fmt.Errorf("Repo: map struct too large (%d)", extra)
5001 }
5002
5003 n := extra
5004
5005 nameBuf := make([]byte, 11)
5006 for i := uint64(0); i < n; i++ {
5007 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5008 if err != nil {
5009 return err
5010 }
5011
5012 if !ok {
5013 // Field doesn't exist on this type, so ignore it
5014 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5015 return err
5016 }
5017 continue
5018 }
5019
5020 switch string(nameBuf[:nameLen]) {
5021 // t.Knot (string) (string)
5022 case "knot":
5023
5024 {
5025 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5026 if err != nil {
5027 return err
5028 }
5029
5030 t.Knot = string(sval)
5031 }
5032 // t.Name (string) (string)
5033 case "name":
5034
5035 {
5036 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5037 if err != nil {
5038 return err
5039 }
5040
5041 t.Name = string(sval)
5042 }
5043 // t.LexiconTypeID (string) (string)
5044 case "$type":
5045
5046 {
5047 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5048 if err != nil {
5049 return err
5050 }
5051
5052 t.LexiconTypeID = string(sval)
5053 }
5054 // t.Owner (string) (string)
5055 case "owner":
5056
5057 {
5058 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5059 if err != nil {
5060 return err
5061 }
5062
5063 t.Owner = string(sval)
5064 }
5065 // t.Source (string) (string)
5066 case "source":
5067
5068 {
5069 b, err := cr.ReadByte()
5070 if err != nil {
5071 return err
5072 }
5073 if b != cbg.CborNull[0] {
5074 if err := cr.UnreadByte(); err != nil {
5075 return err
5076 }
5077
5078 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5079 if err != nil {
5080 return err
5081 }
5082
5083 t.Source = (*string)(&sval)
5084 }
5085 }
5086 // t.Spindle (string) (string)
5087 case "spindle":
5088
5089 {
5090 b, err := cr.ReadByte()
5091 if err != nil {
5092 return err
5093 }
5094 if b != cbg.CborNull[0] {
5095 if err := cr.UnreadByte(); err != nil {
5096 return err
5097 }
5098
5099 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5100 if err != nil {
5101 return err
5102 }
5103
5104 t.Spindle = (*string)(&sval)
5105 }
5106 }
5107 // t.CreatedAt (string) (string)
5108 case "createdAt":
5109
5110 {
5111 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5112 if err != nil {
5113 return err
5114 }
5115
5116 t.CreatedAt = string(sval)
5117 }
5118 // t.Description (string) (string)
5119 case "description":
5120
5121 {
5122 b, err := cr.ReadByte()
5123 if err != nil {
5124 return err
5125 }
5126 if b != cbg.CborNull[0] {
5127 if err := cr.UnreadByte(); err != nil {
5128 return err
5129 }
5130
5131 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5132 if err != nil {
5133 return err
5134 }
5135
5136 t.Description = (*string)(&sval)
5137 }
5138 }
5139
5140 default:
5141 // Field doesn't exist on this type, so ignore it
5142 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5143 return err
5144 }
5145 }
5146 }
5147
5148 return nil
5149}
5150func (t *RepoArtifact) MarshalCBOR(w io.Writer) error {
5151 if t == nil {
5152 _, err := w.Write(cbg.CborNull)
5153 return err
5154 }
5155
5156 cw := cbg.NewCborWriter(w)
5157 fieldCount := 6
5158
5159 if t.Tag == nil {
5160 fieldCount--
5161 }
5162
5163 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5164 return err
5165 }
5166
5167 // t.Tag (util.LexBytes) (slice)
5168 if t.Tag != nil {
5169
5170 if len("tag") > 1000000 {
5171 return xerrors.Errorf("Value in field \"tag\" was too long")
5172 }
5173
5174 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tag"))); err != nil {
5175 return err
5176 }
5177 if _, err := cw.WriteString(string("tag")); err != nil {
5178 return err
5179 }
5180
5181 if len(t.Tag) > 2097152 {
5182 return xerrors.Errorf("Byte array in field t.Tag was too long")
5183 }
5184
5185 if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Tag))); err != nil {
5186 return err
5187 }
5188
5189 if _, err := cw.Write(t.Tag); err != nil {
5190 return err
5191 }
5192
5193 }
5194
5195 // t.Name (string) (string)
5196 if len("name") > 1000000 {
5197 return xerrors.Errorf("Value in field \"name\" was too long")
5198 }
5199
5200 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5201 return err
5202 }
5203 if _, err := cw.WriteString(string("name")); err != nil {
5204 return err
5205 }
5206
5207 if len(t.Name) > 1000000 {
5208 return xerrors.Errorf("Value in field t.Name was too long")
5209 }
5210
5211 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5212 return err
5213 }
5214 if _, err := cw.WriteString(string(t.Name)); err != nil {
5215 return err
5216 }
5217
5218 // t.Repo (string) (string)
5219 if len("repo") > 1000000 {
5220 return xerrors.Errorf("Value in field \"repo\" was too long")
5221 }
5222
5223 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5224 return err
5225 }
5226 if _, err := cw.WriteString(string("repo")); err != nil {
5227 return err
5228 }
5229
5230 if len(t.Repo) > 1000000 {
5231 return xerrors.Errorf("Value in field t.Repo was too long")
5232 }
5233
5234 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
5235 return err
5236 }
5237 if _, err := cw.WriteString(string(t.Repo)); err != nil {
5238 return err
5239 }
5240
5241 // t.LexiconTypeID (string) (string)
5242 if len("$type") > 1000000 {
5243 return xerrors.Errorf("Value in field \"$type\" was too long")
5244 }
5245
5246 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5247 return err
5248 }
5249 if _, err := cw.WriteString(string("$type")); err != nil {
5250 return err
5251 }
5252
5253 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.artifact"))); err != nil {
5254 return err
5255 }
5256 if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil {
5257 return err
5258 }
5259
5260 // t.Artifact (util.LexBlob) (struct)
5261 if len("artifact") > 1000000 {
5262 return xerrors.Errorf("Value in field \"artifact\" was too long")
5263 }
5264
5265 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("artifact"))); err != nil {
5266 return err
5267 }
5268 if _, err := cw.WriteString(string("artifact")); err != nil {
5269 return err
5270 }
5271
5272 if err := t.Artifact.MarshalCBOR(cw); err != nil {
5273 return err
5274 }
5275
5276 // t.CreatedAt (string) (string)
5277 if len("createdAt") > 1000000 {
5278 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5279 }
5280
5281 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5282 return err
5283 }
5284 if _, err := cw.WriteString(string("createdAt")); err != nil {
5285 return err
5286 }
5287
5288 if len(t.CreatedAt) > 1000000 {
5289 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5290 }
5291
5292 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5293 return err
5294 }
5295 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5296 return err
5297 }
5298 return nil
5299}
5300
5301func (t *RepoArtifact) UnmarshalCBOR(r io.Reader) (err error) {
5302 *t = RepoArtifact{}
5303
5304 cr := cbg.NewCborReader(r)
5305
5306 maj, extra, err := cr.ReadHeader()
5307 if err != nil {
5308 return err
5309 }
5310 defer func() {
5311 if err == io.EOF {
5312 err = io.ErrUnexpectedEOF
5313 }
5314 }()
5315
5316 if maj != cbg.MajMap {
5317 return fmt.Errorf("cbor input should be of type map")
5318 }
5319
5320 if extra > cbg.MaxLength {
5321 return fmt.Errorf("RepoArtifact: map struct too large (%d)", extra)
5322 }
5323
5324 n := extra
5325
5326 nameBuf := make([]byte, 9)
5327 for i := uint64(0); i < n; i++ {
5328 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5329 if err != nil {
5330 return err
5331 }
5332
5333 if !ok {
5334 // Field doesn't exist on this type, so ignore it
5335 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5336 return err
5337 }
5338 continue
5339 }
5340
5341 switch string(nameBuf[:nameLen]) {
5342 // t.Tag (util.LexBytes) (slice)
5343 case "tag":
5344
5345 maj, extra, err = cr.ReadHeader()
5346 if err != nil {
5347 return err
5348 }
5349
5350 if extra > 2097152 {
5351 return fmt.Errorf("t.Tag: byte array too large (%d)", extra)
5352 }
5353 if maj != cbg.MajByteString {
5354 return fmt.Errorf("expected byte array")
5355 }
5356
5357 if extra > 0 {
5358 t.Tag = make([]uint8, extra)
5359 }
5360
5361 if _, err := io.ReadFull(cr, t.Tag); err != nil {
5362 return err
5363 }
5364
5365 // t.Name (string) (string)
5366 case "name":
5367
5368 {
5369 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5370 if err != nil {
5371 return err
5372 }
5373
5374 t.Name = string(sval)
5375 }
5376 // t.Repo (string) (string)
5377 case "repo":
5378
5379 {
5380 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5381 if err != nil {
5382 return err
5383 }
5384
5385 t.Repo = string(sval)
5386 }
5387 // t.LexiconTypeID (string) (string)
5388 case "$type":
5389
5390 {
5391 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5392 if err != nil {
5393 return err
5394 }
5395
5396 t.LexiconTypeID = string(sval)
5397 }
5398 // t.Artifact (util.LexBlob) (struct)
5399 case "artifact":
5400
5401 {
5402
5403 b, err := cr.ReadByte()
5404 if err != nil {
5405 return err
5406 }
5407 if b != cbg.CborNull[0] {
5408 if err := cr.UnreadByte(); err != nil {
5409 return err
5410 }
5411 t.Artifact = new(util.LexBlob)
5412 if err := t.Artifact.UnmarshalCBOR(cr); err != nil {
5413 return xerrors.Errorf("unmarshaling t.Artifact pointer: %w", err)
5414 }
5415 }
5416
5417 }
5418 // t.CreatedAt (string) (string)
5419 case "createdAt":
5420
5421 {
5422 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5423 if err != nil {
5424 return err
5425 }
5426
5427 t.CreatedAt = string(sval)
5428 }
5429
5430 default:
5431 // Field doesn't exist on this type, so ignore it
5432 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5433 return err
5434 }
5435 }
5436 }
5437
5438 return nil
5439}
5440func (t *RepoCollaborator) MarshalCBOR(w io.Writer) error {
5441 if t == nil {
5442 _, err := w.Write(cbg.CborNull)
5443 return err
5444 }
5445
5446 cw := cbg.NewCborWriter(w)
5447
5448 if _, err := cw.Write([]byte{164}); err != nil {
5449 return err
5450 }
5451
5452 // t.Repo (string) (string)
5453 if len("repo") > 1000000 {
5454 return xerrors.Errorf("Value in field \"repo\" was too long")
5455 }
5456
5457 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5458 return err
5459 }
5460 if _, err := cw.WriteString(string("repo")); err != nil {
5461 return err
5462 }
5463
5464 if len(t.Repo) > 1000000 {
5465 return xerrors.Errorf("Value in field t.Repo was too long")
5466 }
5467
5468 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
5469 return err
5470 }
5471 if _, err := cw.WriteString(string(t.Repo)); err != nil {
5472 return err
5473 }
5474
5475 // t.LexiconTypeID (string) (string)
5476 if len("$type") > 1000000 {
5477 return xerrors.Errorf("Value in field \"$type\" was too long")
5478 }
5479
5480 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5481 return err
5482 }
5483 if _, err := cw.WriteString(string("$type")); err != nil {
5484 return err
5485 }
5486
5487 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.collaborator"))); err != nil {
5488 return err
5489 }
5490 if _, err := cw.WriteString(string("sh.tangled.repo.collaborator")); err != nil {
5491 return err
5492 }
5493
5494 // t.Subject (string) (string)
5495 if len("subject") > 1000000 {
5496 return xerrors.Errorf("Value in field \"subject\" was too long")
5497 }
5498
5499 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
5500 return err
5501 }
5502 if _, err := cw.WriteString(string("subject")); err != nil {
5503 return err
5504 }
5505
5506 if len(t.Subject) > 1000000 {
5507 return xerrors.Errorf("Value in field t.Subject was too long")
5508 }
5509
5510 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
5511 return err
5512 }
5513 if _, err := cw.WriteString(string(t.Subject)); err != nil {
5514 return err
5515 }
5516
5517 // t.CreatedAt (string) (string)
5518 if len("createdAt") > 1000000 {
5519 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5520 }
5521
5522 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5523 return err
5524 }
5525 if _, err := cw.WriteString(string("createdAt")); err != nil {
5526 return err
5527 }
5528
5529 if len(t.CreatedAt) > 1000000 {
5530 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5531 }
5532
5533 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5534 return err
5535 }
5536 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5537 return err
5538 }
5539 return nil
5540}
5541
5542func (t *RepoCollaborator) UnmarshalCBOR(r io.Reader) (err error) {
5543 *t = RepoCollaborator{}
5544
5545 cr := cbg.NewCborReader(r)
5546
5547 maj, extra, err := cr.ReadHeader()
5548 if err != nil {
5549 return err
5550 }
5551 defer func() {
5552 if err == io.EOF {
5553 err = io.ErrUnexpectedEOF
5554 }
5555 }()
5556
5557 if maj != cbg.MajMap {
5558 return fmt.Errorf("cbor input should be of type map")
5559 }
5560
5561 if extra > cbg.MaxLength {
5562 return fmt.Errorf("RepoCollaborator: map struct too large (%d)", extra)
5563 }
5564
5565 n := extra
5566
5567 nameBuf := make([]byte, 9)
5568 for i := uint64(0); i < n; i++ {
5569 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5570 if err != nil {
5571 return err
5572 }
5573
5574 if !ok {
5575 // Field doesn't exist on this type, so ignore it
5576 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5577 return err
5578 }
5579 continue
5580 }
5581
5582 switch string(nameBuf[:nameLen]) {
5583 // t.Repo (string) (string)
5584 case "repo":
5585
5586 {
5587 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5588 if err != nil {
5589 return err
5590 }
5591
5592 t.Repo = string(sval)
5593 }
5594 // t.LexiconTypeID (string) (string)
5595 case "$type":
5596
5597 {
5598 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5599 if err != nil {
5600 return err
5601 }
5602
5603 t.LexiconTypeID = string(sval)
5604 }
5605 // t.Subject (string) (string)
5606 case "subject":
5607
5608 {
5609 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5610 if err != nil {
5611 return err
5612 }
5613
5614 t.Subject = string(sval)
5615 }
5616 // t.CreatedAt (string) (string)
5617 case "createdAt":
5618
5619 {
5620 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5621 if err != nil {
5622 return err
5623 }
5624
5625 t.CreatedAt = string(sval)
5626 }
5627
5628 default:
5629 // Field doesn't exist on this type, so ignore it
5630 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5631 return err
5632 }
5633 }
5634 }
5635
5636 return nil
5637}
5638func (t *RepoIssue) MarshalCBOR(w io.Writer) error {
5639 if t == nil {
5640 _, err := w.Write(cbg.CborNull)
5641 return err
5642 }
5643
5644 cw := cbg.NewCborWriter(w)
5645 fieldCount := 7
5646
5647 if t.Body == nil {
5648 fieldCount--
5649 }
5650
5651 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5652 return err
5653 }
5654
5655 // t.Body (string) (string)
5656 if t.Body != nil {
5657
5658 if len("body") > 1000000 {
5659 return xerrors.Errorf("Value in field \"body\" was too long")
5660 }
5661
5662 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
5663 return err
5664 }
5665 if _, err := cw.WriteString(string("body")); err != nil {
5666 return err
5667 }
5668
5669 if t.Body == nil {
5670 if _, err := cw.Write(cbg.CborNull); err != nil {
5671 return err
5672 }
5673 } else {
5674 if len(*t.Body) > 1000000 {
5675 return xerrors.Errorf("Value in field t.Body was too long")
5676 }
5677
5678 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
5679 return err
5680 }
5681 if _, err := cw.WriteString(string(*t.Body)); err != nil {
5682 return err
5683 }
5684 }
5685 }
5686
5687 // t.Repo (string) (string)
5688 if len("repo") > 1000000 {
5689 return xerrors.Errorf("Value in field \"repo\" was too long")
5690 }
5691
5692 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5693 return err
5694 }
5695 if _, err := cw.WriteString(string("repo")); err != nil {
5696 return err
5697 }
5698
5699 if len(t.Repo) > 1000000 {
5700 return xerrors.Errorf("Value in field t.Repo was too long")
5701 }
5702
5703 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
5704 return err
5705 }
5706 if _, err := cw.WriteString(string(t.Repo)); err != nil {
5707 return err
5708 }
5709
5710 // t.LexiconTypeID (string) (string)
5711 if len("$type") > 1000000 {
5712 return xerrors.Errorf("Value in field \"$type\" was too long")
5713 }
5714
5715 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5716 return err
5717 }
5718 if _, err := cw.WriteString(string("$type")); err != nil {
5719 return err
5720 }
5721
5722 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil {
5723 return err
5724 }
5725 if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil {
5726 return err
5727 }
5728
5729 // t.Owner (string) (string)
5730 if len("owner") > 1000000 {
5731 return xerrors.Errorf("Value in field \"owner\" was too long")
5732 }
5733
5734 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
5735 return err
5736 }
5737 if _, err := cw.WriteString(string("owner")); err != nil {
5738 return err
5739 }
5740
5741 if len(t.Owner) > 1000000 {
5742 return xerrors.Errorf("Value in field t.Owner was too long")
5743 }
5744
5745 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {
5746 return err
5747 }
5748 if _, err := cw.WriteString(string(t.Owner)); err != nil {
5749 return err
5750 }
5751
5752 // t.Title (string) (string)
5753 if len("title") > 1000000 {
5754 return xerrors.Errorf("Value in field \"title\" was too long")
5755 }
5756
5757 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
5758 return err
5759 }
5760 if _, err := cw.WriteString(string("title")); err != nil {
5761 return err
5762 }
5763
5764 if len(t.Title) > 1000000 {
5765 return xerrors.Errorf("Value in field t.Title was too long")
5766 }
5767
5768 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
5769 return err
5770 }
5771 if _, err := cw.WriteString(string(t.Title)); err != nil {
5772 return err
5773 }
5774
5775 // t.IssueId (int64) (int64)
5776 if len("issueId") > 1000000 {
5777 return xerrors.Errorf("Value in field \"issueId\" was too long")
5778 }
5779
5780 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issueId"))); err != nil {
5781 return err
5782 }
5783 if _, err := cw.WriteString(string("issueId")); err != nil {
5784 return err
5785 }
5786
5787 if t.IssueId >= 0 {
5788 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.IssueId)); err != nil {
5789 return err
5790 }
5791 } else {
5792 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.IssueId-1)); err != nil {
5793 return err
5794 }
5795 }
5796
5797 // t.CreatedAt (string) (string)
5798 if len("createdAt") > 1000000 {
5799 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5800 }
5801
5802 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5803 return err
5804 }
5805 if _, err := cw.WriteString(string("createdAt")); err != nil {
5806 return err
5807 }
5808
5809 if len(t.CreatedAt) > 1000000 {
5810 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5811 }
5812
5813 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5814 return err
5815 }
5816 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5817 return err
5818 }
5819 return nil
5820}
5821
5822func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) {
5823 *t = RepoIssue{}
5824
5825 cr := cbg.NewCborReader(r)
5826
5827 maj, extra, err := cr.ReadHeader()
5828 if err != nil {
5829 return err
5830 }
5831 defer func() {
5832 if err == io.EOF {
5833 err = io.ErrUnexpectedEOF
5834 }
5835 }()
5836
5837 if maj != cbg.MajMap {
5838 return fmt.Errorf("cbor input should be of type map")
5839 }
5840
5841 if extra > cbg.MaxLength {
5842 return fmt.Errorf("RepoIssue: map struct too large (%d)", extra)
5843 }
5844
5845 n := extra
5846
5847 nameBuf := make([]byte, 9)
5848 for i := uint64(0); i < n; i++ {
5849 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5850 if err != nil {
5851 return err
5852 }
5853
5854 if !ok {
5855 // Field doesn't exist on this type, so ignore it
5856 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5857 return err
5858 }
5859 continue
5860 }
5861
5862 switch string(nameBuf[:nameLen]) {
5863 // t.Body (string) (string)
5864 case "body":
5865
5866 {
5867 b, err := cr.ReadByte()
5868 if err != nil {
5869 return err
5870 }
5871 if b != cbg.CborNull[0] {
5872 if err := cr.UnreadByte(); err != nil {
5873 return err
5874 }
5875
5876 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5877 if err != nil {
5878 return err
5879 }
5880
5881 t.Body = (*string)(&sval)
5882 }
5883 }
5884 // t.Repo (string) (string)
5885 case "repo":
5886
5887 {
5888 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5889 if err != nil {
5890 return err
5891 }
5892
5893 t.Repo = string(sval)
5894 }
5895 // t.LexiconTypeID (string) (string)
5896 case "$type":
5897
5898 {
5899 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5900 if err != nil {
5901 return err
5902 }
5903
5904 t.LexiconTypeID = string(sval)
5905 }
5906 // t.Owner (string) (string)
5907 case "owner":
5908
5909 {
5910 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5911 if err != nil {
5912 return err
5913 }
5914
5915 t.Owner = string(sval)
5916 }
5917 // t.Title (string) (string)
5918 case "title":
5919
5920 {
5921 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5922 if err != nil {
5923 return err
5924 }
5925
5926 t.Title = string(sval)
5927 }
5928 // t.IssueId (int64) (int64)
5929 case "issueId":
5930 {
5931 maj, extra, err := cr.ReadHeader()
5932 if err != nil {
5933 return err
5934 }
5935 var extraI int64
5936 switch maj {
5937 case cbg.MajUnsignedInt:
5938 extraI = int64(extra)
5939 if extraI < 0 {
5940 return fmt.Errorf("int64 positive overflow")
5941 }
5942 case cbg.MajNegativeInt:
5943 extraI = int64(extra)
5944 if extraI < 0 {
5945 return fmt.Errorf("int64 negative overflow")
5946 }
5947 extraI = -1 - extraI
5948 default:
5949 return fmt.Errorf("wrong type for int64 field: %d", maj)
5950 }
5951
5952 t.IssueId = int64(extraI)
5953 }
5954 // t.CreatedAt (string) (string)
5955 case "createdAt":
5956
5957 {
5958 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5959 if err != nil {
5960 return err
5961 }
5962
5963 t.CreatedAt = string(sval)
5964 }
5965
5966 default:
5967 // Field doesn't exist on this type, so ignore it
5968 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5969 return err
5970 }
5971 }
5972 }
5973
5974 return nil
5975}
5976func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error {
5977 if t == nil {
5978 _, err := w.Write(cbg.CborNull)
5979 return err
5980 }
5981
5982 cw := cbg.NewCborWriter(w)
5983 fieldCount := 7
5984
5985 if t.CommentId == nil {
5986 fieldCount--
5987 }
5988
5989 if t.Owner == nil {
5990 fieldCount--
5991 }
5992
5993 if t.Repo == nil {
5994 fieldCount--
5995 }
5996
5997 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5998 return err
5999 }
6000
6001 // t.Body (string) (string)
6002 if len("body") > 1000000 {
6003 return xerrors.Errorf("Value in field \"body\" was too long")
6004 }
6005
6006 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
6007 return err
6008 }
6009 if _, err := cw.WriteString(string("body")); err != nil {
6010 return err
6011 }
6012
6013 if len(t.Body) > 1000000 {
6014 return xerrors.Errorf("Value in field t.Body was too long")
6015 }
6016
6017 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
6018 return err
6019 }
6020 if _, err := cw.WriteString(string(t.Body)); err != nil {
6021 return err
6022 }
6023
6024 // t.Repo (string) (string)
6025 if t.Repo != nil {
6026
6027 if len("repo") > 1000000 {
6028 return xerrors.Errorf("Value in field \"repo\" was too long")
6029 }
6030
6031 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6032 return err
6033 }
6034 if _, err := cw.WriteString(string("repo")); err != nil {
6035 return err
6036 }
6037
6038 if t.Repo == nil {
6039 if _, err := cw.Write(cbg.CborNull); err != nil {
6040 return err
6041 }
6042 } else {
6043 if len(*t.Repo) > 1000000 {
6044 return xerrors.Errorf("Value in field t.Repo was too long")
6045 }
6046
6047 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
6048 return err
6049 }
6050 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
6051 return err
6052 }
6053 }
6054 }
6055
6056 // t.LexiconTypeID (string) (string)
6057 if len("$type") > 1000000 {
6058 return xerrors.Errorf("Value in field \"$type\" was too long")
6059 }
6060
6061 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6062 return err
6063 }
6064 if _, err := cw.WriteString(string("$type")); err != nil {
6065 return err
6066 }
6067
6068 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil {
6069 return err
6070 }
6071 if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil {
6072 return err
6073 }
6074
6075 // t.Issue (string) (string)
6076 if len("issue") > 1000000 {
6077 return xerrors.Errorf("Value in field \"issue\" was too long")
6078 }
6079
6080 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
6081 return err
6082 }
6083 if _, err := cw.WriteString(string("issue")); err != nil {
6084 return err
6085 }
6086
6087 if len(t.Issue) > 1000000 {
6088 return xerrors.Errorf("Value in field t.Issue was too long")
6089 }
6090
6091 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
6092 return err
6093 }
6094 if _, err := cw.WriteString(string(t.Issue)); err != nil {
6095 return err
6096 }
6097
6098 // t.Owner (string) (string)
6099 if t.Owner != nil {
6100
6101 if len("owner") > 1000000 {
6102 return xerrors.Errorf("Value in field \"owner\" was too long")
6103 }
6104
6105 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
6106 return err
6107 }
6108 if _, err := cw.WriteString(string("owner")); err != nil {
6109 return err
6110 }
6111
6112 if t.Owner == nil {
6113 if _, err := cw.Write(cbg.CborNull); err != nil {
6114 return err
6115 }
6116 } else {
6117 if len(*t.Owner) > 1000000 {
6118 return xerrors.Errorf("Value in field t.Owner was too long")
6119 }
6120
6121 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Owner))); err != nil {
6122 return err
6123 }
6124 if _, err := cw.WriteString(string(*t.Owner)); err != nil {
6125 return err
6126 }
6127 }
6128 }
6129
6130 // t.CommentId (int64) (int64)
6131 if t.CommentId != nil {
6132
6133 if len("commentId") > 1000000 {
6134 return xerrors.Errorf("Value in field \"commentId\" was too long")
6135 }
6136
6137 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commentId"))); err != nil {
6138 return err
6139 }
6140 if _, err := cw.WriteString(string("commentId")); err != nil {
6141 return err
6142 }
6143
6144 if t.CommentId == nil {
6145 if _, err := cw.Write(cbg.CborNull); err != nil {
6146 return err
6147 }
6148 } else {
6149 if *t.CommentId >= 0 {
6150 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.CommentId)); err != nil {
6151 return err
6152 }
6153 } else {
6154 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.CommentId-1)); err != nil {
6155 return err
6156 }
6157 }
6158 }
6159
6160 }
6161
6162 // t.CreatedAt (string) (string)
6163 if len("createdAt") > 1000000 {
6164 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6165 }
6166
6167 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6168 return err
6169 }
6170 if _, err := cw.WriteString(string("createdAt")); err != nil {
6171 return err
6172 }
6173
6174 if len(t.CreatedAt) > 1000000 {
6175 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6176 }
6177
6178 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6179 return err
6180 }
6181 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6182 return err
6183 }
6184 return nil
6185}
6186
6187func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) {
6188 *t = RepoIssueComment{}
6189
6190 cr := cbg.NewCborReader(r)
6191
6192 maj, extra, err := cr.ReadHeader()
6193 if err != nil {
6194 return err
6195 }
6196 defer func() {
6197 if err == io.EOF {
6198 err = io.ErrUnexpectedEOF
6199 }
6200 }()
6201
6202 if maj != cbg.MajMap {
6203 return fmt.Errorf("cbor input should be of type map")
6204 }
6205
6206 if extra > cbg.MaxLength {
6207 return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra)
6208 }
6209
6210 n := extra
6211
6212 nameBuf := make([]byte, 9)
6213 for i := uint64(0); i < n; i++ {
6214 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6215 if err != nil {
6216 return err
6217 }
6218
6219 if !ok {
6220 // Field doesn't exist on this type, so ignore it
6221 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6222 return err
6223 }
6224 continue
6225 }
6226
6227 switch string(nameBuf[:nameLen]) {
6228 // t.Body (string) (string)
6229 case "body":
6230
6231 {
6232 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6233 if err != nil {
6234 return err
6235 }
6236
6237 t.Body = string(sval)
6238 }
6239 // t.Repo (string) (string)
6240 case "repo":
6241
6242 {
6243 b, err := cr.ReadByte()
6244 if err != nil {
6245 return err
6246 }
6247 if b != cbg.CborNull[0] {
6248 if err := cr.UnreadByte(); err != nil {
6249 return err
6250 }
6251
6252 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6253 if err != nil {
6254 return err
6255 }
6256
6257 t.Repo = (*string)(&sval)
6258 }
6259 }
6260 // t.LexiconTypeID (string) (string)
6261 case "$type":
6262
6263 {
6264 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6265 if err != nil {
6266 return err
6267 }
6268
6269 t.LexiconTypeID = string(sval)
6270 }
6271 // t.Issue (string) (string)
6272 case "issue":
6273
6274 {
6275 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6276 if err != nil {
6277 return err
6278 }
6279
6280 t.Issue = string(sval)
6281 }
6282 // t.Owner (string) (string)
6283 case "owner":
6284
6285 {
6286 b, err := cr.ReadByte()
6287 if err != nil {
6288 return err
6289 }
6290 if b != cbg.CborNull[0] {
6291 if err := cr.UnreadByte(); err != nil {
6292 return err
6293 }
6294
6295 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6296 if err != nil {
6297 return err
6298 }
6299
6300 t.Owner = (*string)(&sval)
6301 }
6302 }
6303 // t.CommentId (int64) (int64)
6304 case "commentId":
6305 {
6306
6307 b, err := cr.ReadByte()
6308 if err != nil {
6309 return err
6310 }
6311 if b != cbg.CborNull[0] {
6312 if err := cr.UnreadByte(); err != nil {
6313 return err
6314 }
6315 maj, extra, err := cr.ReadHeader()
6316 if err != nil {
6317 return err
6318 }
6319 var extraI int64
6320 switch maj {
6321 case cbg.MajUnsignedInt:
6322 extraI = int64(extra)
6323 if extraI < 0 {
6324 return fmt.Errorf("int64 positive overflow")
6325 }
6326 case cbg.MajNegativeInt:
6327 extraI = int64(extra)
6328 if extraI < 0 {
6329 return fmt.Errorf("int64 negative overflow")
6330 }
6331 extraI = -1 - extraI
6332 default:
6333 return fmt.Errorf("wrong type for int64 field: %d", maj)
6334 }
6335
6336 t.CommentId = (*int64)(&extraI)
6337 }
6338 }
6339 // t.CreatedAt (string) (string)
6340 case "createdAt":
6341
6342 {
6343 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6344 if err != nil {
6345 return err
6346 }
6347
6348 t.CreatedAt = string(sval)
6349 }
6350
6351 default:
6352 // Field doesn't exist on this type, so ignore it
6353 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6354 return err
6355 }
6356 }
6357 }
6358
6359 return nil
6360}
6361func (t *RepoIssueState) MarshalCBOR(w io.Writer) error {
6362 if t == nil {
6363 _, err := w.Write(cbg.CborNull)
6364 return err
6365 }
6366
6367 cw := cbg.NewCborWriter(w)
6368
6369 if _, err := cw.Write([]byte{163}); err != nil {
6370 return err
6371 }
6372
6373 // t.LexiconTypeID (string) (string)
6374 if len("$type") > 1000000 {
6375 return xerrors.Errorf("Value in field \"$type\" was too long")
6376 }
6377
6378 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6379 return err
6380 }
6381 if _, err := cw.WriteString(string("$type")); err != nil {
6382 return err
6383 }
6384
6385 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil {
6386 return err
6387 }
6388 if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil {
6389 return err
6390 }
6391
6392 // t.Issue (string) (string)
6393 if len("issue") > 1000000 {
6394 return xerrors.Errorf("Value in field \"issue\" was too long")
6395 }
6396
6397 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
6398 return err
6399 }
6400 if _, err := cw.WriteString(string("issue")); err != nil {
6401 return err
6402 }
6403
6404 if len(t.Issue) > 1000000 {
6405 return xerrors.Errorf("Value in field t.Issue was too long")
6406 }
6407
6408 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
6409 return err
6410 }
6411 if _, err := cw.WriteString(string(t.Issue)); err != nil {
6412 return err
6413 }
6414
6415 // t.State (string) (string)
6416 if len("state") > 1000000 {
6417 return xerrors.Errorf("Value in field \"state\" was too long")
6418 }
6419
6420 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil {
6421 return err
6422 }
6423 if _, err := cw.WriteString(string("state")); err != nil {
6424 return err
6425 }
6426
6427 if len(t.State) > 1000000 {
6428 return xerrors.Errorf("Value in field t.State was too long")
6429 }
6430
6431 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil {
6432 return err
6433 }
6434 if _, err := cw.WriteString(string(t.State)); err != nil {
6435 return err
6436 }
6437 return nil
6438}
6439
6440func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) {
6441 *t = RepoIssueState{}
6442
6443 cr := cbg.NewCborReader(r)
6444
6445 maj, extra, err := cr.ReadHeader()
6446 if err != nil {
6447 return err
6448 }
6449 defer func() {
6450 if err == io.EOF {
6451 err = io.ErrUnexpectedEOF
6452 }
6453 }()
6454
6455 if maj != cbg.MajMap {
6456 return fmt.Errorf("cbor input should be of type map")
6457 }
6458
6459 if extra > cbg.MaxLength {
6460 return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra)
6461 }
6462
6463 n := extra
6464
6465 nameBuf := make([]byte, 5)
6466 for i := uint64(0); i < n; i++ {
6467 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6468 if err != nil {
6469 return err
6470 }
6471
6472 if !ok {
6473 // Field doesn't exist on this type, so ignore it
6474 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6475 return err
6476 }
6477 continue
6478 }
6479
6480 switch string(nameBuf[:nameLen]) {
6481 // t.LexiconTypeID (string) (string)
6482 case "$type":
6483
6484 {
6485 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6486 if err != nil {
6487 return err
6488 }
6489
6490 t.LexiconTypeID = string(sval)
6491 }
6492 // t.Issue (string) (string)
6493 case "issue":
6494
6495 {
6496 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6497 if err != nil {
6498 return err
6499 }
6500
6501 t.Issue = string(sval)
6502 }
6503 // t.State (string) (string)
6504 case "state":
6505
6506 {
6507 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6508 if err != nil {
6509 return err
6510 }
6511
6512 t.State = string(sval)
6513 }
6514
6515 default:
6516 // Field doesn't exist on this type, so ignore it
6517 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6518 return err
6519 }
6520 }
6521 }
6522
6523 return nil
6524}
6525func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error {
6526 if t == nil {
6527 _, err := w.Write(cbg.CborNull)
6528 return err
6529 }
6530
6531 cw := cbg.NewCborWriter(w)
6532
6533 if _, err := cw.Write([]byte{162}); err != nil {
6534 return err
6535 }
6536
6537 // t.Repo (string) (string)
6538 if len("repo") > 1000000 {
6539 return xerrors.Errorf("Value in field \"repo\" was too long")
6540 }
6541
6542 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6543 return err
6544 }
6545 if _, err := cw.WriteString(string("repo")); err != nil {
6546 return err
6547 }
6548
6549 if len(t.Repo) > 1000000 {
6550 return xerrors.Errorf("Value in field t.Repo was too long")
6551 }
6552
6553 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
6554 return err
6555 }
6556 if _, err := cw.WriteString(string(t.Repo)); err != nil {
6557 return err
6558 }
6559
6560 // t.Branch (string) (string)
6561 if len("branch") > 1000000 {
6562 return xerrors.Errorf("Value in field \"branch\" was too long")
6563 }
6564
6565 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
6566 return err
6567 }
6568 if _, err := cw.WriteString(string("branch")); err != nil {
6569 return err
6570 }
6571
6572 if len(t.Branch) > 1000000 {
6573 return xerrors.Errorf("Value in field t.Branch was too long")
6574 }
6575
6576 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
6577 return err
6578 }
6579 if _, err := cw.WriteString(string(t.Branch)); err != nil {
6580 return err
6581 }
6582 return nil
6583}
6584
6585func (t *RepoPull_Target) UnmarshalCBOR(r io.Reader) (err error) {
6586 *t = RepoPull_Target{}
6587
6588 cr := cbg.NewCborReader(r)
6589
6590 maj, extra, err := cr.ReadHeader()
6591 if err != nil {
6592 return err
6593 }
6594 defer func() {
6595 if err == io.EOF {
6596 err = io.ErrUnexpectedEOF
6597 }
6598 }()
6599
6600 if maj != cbg.MajMap {
6601 return fmt.Errorf("cbor input should be of type map")
6602 }
6603
6604 if extra > cbg.MaxLength {
6605 return fmt.Errorf("RepoPull_Target: map struct too large (%d)", extra)
6606 }
6607
6608 n := extra
6609
6610 nameBuf := make([]byte, 6)
6611 for i := uint64(0); i < n; i++ {
6612 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6613 if err != nil {
6614 return err
6615 }
6616
6617 if !ok {
6618 // Field doesn't exist on this type, so ignore it
6619 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6620 return err
6621 }
6622 continue
6623 }
6624
6625 switch string(nameBuf[:nameLen]) {
6626 // t.Repo (string) (string)
6627 case "repo":
6628
6629 {
6630 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6631 if err != nil {
6632 return err
6633 }
6634
6635 t.Repo = string(sval)
6636 }
6637 // t.Branch (string) (string)
6638 case "branch":
6639
6640 {
6641 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6642 if err != nil {
6643 return err
6644 }
6645
6646 t.Branch = string(sval)
6647 }
6648
6649 default:
6650 // Field doesn't exist on this type, so ignore it
6651 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6652 return err
6653 }
6654 }
6655 }
6656
6657 return nil
6658}
6659func (t *RepoPull) MarshalCBOR(w io.Writer) error {
6660 if t == nil {
6661 _, err := w.Write(cbg.CborNull)
6662 return err
6663 }
6664
6665 cw := cbg.NewCborWriter(w)
6666 fieldCount := 7
6667
6668 if t.Body == nil {
6669 fieldCount--
6670 }
6671
6672 if t.Source == nil {
6673 fieldCount--
6674 }
6675
6676 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6677 return err
6678 }
6679
6680 // t.Body (string) (string)
6681 if t.Body != nil {
6682
6683 if len("body") > 1000000 {
6684 return xerrors.Errorf("Value in field \"body\" was too long")
6685 }
6686
6687 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
6688 return err
6689 }
6690 if _, err := cw.WriteString(string("body")); err != nil {
6691 return err
6692 }
6693
6694 if t.Body == nil {
6695 if _, err := cw.Write(cbg.CborNull); err != nil {
6696 return err
6697 }
6698 } else {
6699 if len(*t.Body) > 1000000 {
6700 return xerrors.Errorf("Value in field t.Body was too long")
6701 }
6702
6703 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
6704 return err
6705 }
6706 if _, err := cw.WriteString(string(*t.Body)); err != nil {
6707 return err
6708 }
6709 }
6710 }
6711
6712 // t.LexiconTypeID (string) (string)
6713 if len("$type") > 1000000 {
6714 return xerrors.Errorf("Value in field \"$type\" was too long")
6715 }
6716
6717 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6718 return err
6719 }
6720 if _, err := cw.WriteString(string("$type")); err != nil {
6721 return err
6722 }
6723
6724 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil {
6725 return err
6726 }
6727 if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil {
6728 return err
6729 }
6730
6731 // t.Patch (string) (string)
6732 if len("patch") > 1000000 {
6733 return xerrors.Errorf("Value in field \"patch\" was too long")
6734 }
6735
6736 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil {
6737 return err
6738 }
6739 if _, err := cw.WriteString(string("patch")); err != nil {
6740 return err
6741 }
6742
6743 if len(t.Patch) > 1000000 {
6744 return xerrors.Errorf("Value in field t.Patch was too long")
6745 }
6746
6747 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Patch))); err != nil {
6748 return err
6749 }
6750 if _, err := cw.WriteString(string(t.Patch)); err != nil {
6751 return err
6752 }
6753
6754 // t.Title (string) (string)
6755 if len("title") > 1000000 {
6756 return xerrors.Errorf("Value in field \"title\" was too long")
6757 }
6758
6759 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
6760 return err
6761 }
6762 if _, err := cw.WriteString(string("title")); err != nil {
6763 return err
6764 }
6765
6766 if len(t.Title) > 1000000 {
6767 return xerrors.Errorf("Value in field t.Title was too long")
6768 }
6769
6770 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
6771 return err
6772 }
6773 if _, err := cw.WriteString(string(t.Title)); err != nil {
6774 return err
6775 }
6776
6777 // t.Source (tangled.RepoPull_Source) (struct)
6778 if t.Source != nil {
6779
6780 if len("source") > 1000000 {
6781 return xerrors.Errorf("Value in field \"source\" was too long")
6782 }
6783
6784 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
6785 return err
6786 }
6787 if _, err := cw.WriteString(string("source")); err != nil {
6788 return err
6789 }
6790
6791 if err := t.Source.MarshalCBOR(cw); err != nil {
6792 return err
6793 }
6794 }
6795
6796 // t.Target (tangled.RepoPull_Target) (struct)
6797 if len("target") > 1000000 {
6798 return xerrors.Errorf("Value in field \"target\" was too long")
6799 }
6800
6801 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("target"))); err != nil {
6802 return err
6803 }
6804 if _, err := cw.WriteString(string("target")); err != nil {
6805 return err
6806 }
6807
6808 if err := t.Target.MarshalCBOR(cw); err != nil {
6809 return err
6810 }
6811
6812 // t.CreatedAt (string) (string)
6813 if len("createdAt") > 1000000 {
6814 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6815 }
6816
6817 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6818 return err
6819 }
6820 if _, err := cw.WriteString(string("createdAt")); err != nil {
6821 return err
6822 }
6823
6824 if len(t.CreatedAt) > 1000000 {
6825 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6826 }
6827
6828 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6829 return err
6830 }
6831 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6832 return err
6833 }
6834 return nil
6835}
6836
6837func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) {
6838 *t = RepoPull{}
6839
6840 cr := cbg.NewCborReader(r)
6841
6842 maj, extra, err := cr.ReadHeader()
6843 if err != nil {
6844 return err
6845 }
6846 defer func() {
6847 if err == io.EOF {
6848 err = io.ErrUnexpectedEOF
6849 }
6850 }()
6851
6852 if maj != cbg.MajMap {
6853 return fmt.Errorf("cbor input should be of type map")
6854 }
6855
6856 if extra > cbg.MaxLength {
6857 return fmt.Errorf("RepoPull: map struct too large (%d)", extra)
6858 }
6859
6860 n := extra
6861
6862 nameBuf := make([]byte, 9)
6863 for i := uint64(0); i < n; i++ {
6864 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6865 if err != nil {
6866 return err
6867 }
6868
6869 if !ok {
6870 // Field doesn't exist on this type, so ignore it
6871 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6872 return err
6873 }
6874 continue
6875 }
6876
6877 switch string(nameBuf[:nameLen]) {
6878 // t.Body (string) (string)
6879 case "body":
6880
6881 {
6882 b, err := cr.ReadByte()
6883 if err != nil {
6884 return err
6885 }
6886 if b != cbg.CborNull[0] {
6887 if err := cr.UnreadByte(); err != nil {
6888 return err
6889 }
6890
6891 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6892 if err != nil {
6893 return err
6894 }
6895
6896 t.Body = (*string)(&sval)
6897 }
6898 }
6899 // t.LexiconTypeID (string) (string)
6900 case "$type":
6901
6902 {
6903 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6904 if err != nil {
6905 return err
6906 }
6907
6908 t.LexiconTypeID = string(sval)
6909 }
6910 // t.Patch (string) (string)
6911 case "patch":
6912
6913 {
6914 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6915 if err != nil {
6916 return err
6917 }
6918
6919 t.Patch = string(sval)
6920 }
6921 // t.Title (string) (string)
6922 case "title":
6923
6924 {
6925 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6926 if err != nil {
6927 return err
6928 }
6929
6930 t.Title = string(sval)
6931 }
6932 // t.Source (tangled.RepoPull_Source) (struct)
6933 case "source":
6934
6935 {
6936
6937 b, err := cr.ReadByte()
6938 if err != nil {
6939 return err
6940 }
6941 if b != cbg.CborNull[0] {
6942 if err := cr.UnreadByte(); err != nil {
6943 return err
6944 }
6945 t.Source = new(RepoPull_Source)
6946 if err := t.Source.UnmarshalCBOR(cr); err != nil {
6947 return xerrors.Errorf("unmarshaling t.Source pointer: %w", err)
6948 }
6949 }
6950
6951 }
6952 // t.Target (tangled.RepoPull_Target) (struct)
6953 case "target":
6954
6955 {
6956
6957 b, err := cr.ReadByte()
6958 if err != nil {
6959 return err
6960 }
6961 if b != cbg.CborNull[0] {
6962 if err := cr.UnreadByte(); err != nil {
6963 return err
6964 }
6965 t.Target = new(RepoPull_Target)
6966 if err := t.Target.UnmarshalCBOR(cr); err != nil {
6967 return xerrors.Errorf("unmarshaling t.Target pointer: %w", err)
6968 }
6969 }
6970
6971 }
6972 // t.CreatedAt (string) (string)
6973 case "createdAt":
6974
6975 {
6976 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6977 if err != nil {
6978 return err
6979 }
6980
6981 t.CreatedAt = string(sval)
6982 }
6983
6984 default:
6985 // Field doesn't exist on this type, so ignore it
6986 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6987 return err
6988 }
6989 }
6990 }
6991
6992 return nil
6993}
6994func (t *RepoPullComment) MarshalCBOR(w io.Writer) error {
6995 if t == nil {
6996 _, err := w.Write(cbg.CborNull)
6997 return err
6998 }
6999
7000 cw := cbg.NewCborWriter(w)
7001
7002 if _, err := cw.Write([]byte{164}); err != nil {
7003 return err
7004 }
7005
7006 // t.Body (string) (string)
7007 if len("body") > 1000000 {
7008 return xerrors.Errorf("Value in field \"body\" was too long")
7009 }
7010
7011 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
7012 return err
7013 }
7014 if _, err := cw.WriteString(string("body")); err != nil {
7015 return err
7016 }
7017
7018 if len(t.Body) > 1000000 {
7019 return xerrors.Errorf("Value in field t.Body was too long")
7020 }
7021
7022 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
7023 return err
7024 }
7025 if _, err := cw.WriteString(string(t.Body)); err != nil {
7026 return err
7027 }
7028
7029 // t.Pull (string) (string)
7030 if len("pull") > 1000000 {
7031 return xerrors.Errorf("Value in field \"pull\" was too long")
7032 }
7033
7034 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
7035 return err
7036 }
7037 if _, err := cw.WriteString(string("pull")); err != nil {
7038 return err
7039 }
7040
7041 if len(t.Pull) > 1000000 {
7042 return xerrors.Errorf("Value in field t.Pull was too long")
7043 }
7044
7045 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
7046 return err
7047 }
7048 if _, err := cw.WriteString(string(t.Pull)); err != nil {
7049 return err
7050 }
7051
7052 // t.LexiconTypeID (string) (string)
7053 if len("$type") > 1000000 {
7054 return xerrors.Errorf("Value in field \"$type\" was too long")
7055 }
7056
7057 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7058 return err
7059 }
7060 if _, err := cw.WriteString(string("$type")); err != nil {
7061 return err
7062 }
7063
7064 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.comment"))); err != nil {
7065 return err
7066 }
7067 if _, err := cw.WriteString(string("sh.tangled.repo.pull.comment")); err != nil {
7068 return err
7069 }
7070
7071 // t.CreatedAt (string) (string)
7072 if len("createdAt") > 1000000 {
7073 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7074 }
7075
7076 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7077 return err
7078 }
7079 if _, err := cw.WriteString(string("createdAt")); err != nil {
7080 return err
7081 }
7082
7083 if len(t.CreatedAt) > 1000000 {
7084 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7085 }
7086
7087 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7088 return err
7089 }
7090 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7091 return err
7092 }
7093 return nil
7094}
7095
7096func (t *RepoPullComment) UnmarshalCBOR(r io.Reader) (err error) {
7097 *t = RepoPullComment{}
7098
7099 cr := cbg.NewCborReader(r)
7100
7101 maj, extra, err := cr.ReadHeader()
7102 if err != nil {
7103 return err
7104 }
7105 defer func() {
7106 if err == io.EOF {
7107 err = io.ErrUnexpectedEOF
7108 }
7109 }()
7110
7111 if maj != cbg.MajMap {
7112 return fmt.Errorf("cbor input should be of type map")
7113 }
7114
7115 if extra > cbg.MaxLength {
7116 return fmt.Errorf("RepoPullComment: map struct too large (%d)", extra)
7117 }
7118
7119 n := extra
7120
7121 nameBuf := make([]byte, 9)
7122 for i := uint64(0); i < n; i++ {
7123 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7124 if err != nil {
7125 return err
7126 }
7127
7128 if !ok {
7129 // Field doesn't exist on this type, so ignore it
7130 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7131 return err
7132 }
7133 continue
7134 }
7135
7136 switch string(nameBuf[:nameLen]) {
7137 // t.Body (string) (string)
7138 case "body":
7139
7140 {
7141 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7142 if err != nil {
7143 return err
7144 }
7145
7146 t.Body = string(sval)
7147 }
7148 // t.Pull (string) (string)
7149 case "pull":
7150
7151 {
7152 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7153 if err != nil {
7154 return err
7155 }
7156
7157 t.Pull = string(sval)
7158 }
7159 // t.LexiconTypeID (string) (string)
7160 case "$type":
7161
7162 {
7163 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7164 if err != nil {
7165 return err
7166 }
7167
7168 t.LexiconTypeID = string(sval)
7169 }
7170 // t.CreatedAt (string) (string)
7171 case "createdAt":
7172
7173 {
7174 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7175 if err != nil {
7176 return err
7177 }
7178
7179 t.CreatedAt = string(sval)
7180 }
7181
7182 default:
7183 // Field doesn't exist on this type, so ignore it
7184 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7185 return err
7186 }
7187 }
7188 }
7189
7190 return nil
7191}
7192func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error {
7193 if t == nil {
7194 _, err := w.Write(cbg.CborNull)
7195 return err
7196 }
7197
7198 cw := cbg.NewCborWriter(w)
7199 fieldCount := 3
7200
7201 if t.Repo == nil {
7202 fieldCount--
7203 }
7204
7205 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7206 return err
7207 }
7208
7209 // t.Sha (string) (string)
7210 if len("sha") > 1000000 {
7211 return xerrors.Errorf("Value in field \"sha\" was too long")
7212 }
7213
7214 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sha"))); err != nil {
7215 return err
7216 }
7217 if _, err := cw.WriteString(string("sha")); err != nil {
7218 return err
7219 }
7220
7221 if len(t.Sha) > 1000000 {
7222 return xerrors.Errorf("Value in field t.Sha was too long")
7223 }
7224
7225 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Sha))); err != nil {
7226 return err
7227 }
7228 if _, err := cw.WriteString(string(t.Sha)); err != nil {
7229 return err
7230 }
7231
7232 // t.Repo (string) (string)
7233 if t.Repo != nil {
7234
7235 if len("repo") > 1000000 {
7236 return xerrors.Errorf("Value in field \"repo\" was too long")
7237 }
7238
7239 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
7240 return err
7241 }
7242 if _, err := cw.WriteString(string("repo")); err != nil {
7243 return err
7244 }
7245
7246 if t.Repo == nil {
7247 if _, err := cw.Write(cbg.CborNull); err != nil {
7248 return err
7249 }
7250 } else {
7251 if len(*t.Repo) > 1000000 {
7252 return xerrors.Errorf("Value in field t.Repo was too long")
7253 }
7254
7255 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
7256 return err
7257 }
7258 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
7259 return err
7260 }
7261 }
7262 }
7263
7264 // t.Branch (string) (string)
7265 if len("branch") > 1000000 {
7266 return xerrors.Errorf("Value in field \"branch\" was too long")
7267 }
7268
7269 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
7270 return err
7271 }
7272 if _, err := cw.WriteString(string("branch")); err != nil {
7273 return err
7274 }
7275
7276 if len(t.Branch) > 1000000 {
7277 return xerrors.Errorf("Value in field t.Branch was too long")
7278 }
7279
7280 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
7281 return err
7282 }
7283 if _, err := cw.WriteString(string(t.Branch)); err != nil {
7284 return err
7285 }
7286 return nil
7287}
7288
7289func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) {
7290 *t = RepoPull_Source{}
7291
7292 cr := cbg.NewCborReader(r)
7293
7294 maj, extra, err := cr.ReadHeader()
7295 if err != nil {
7296 return err
7297 }
7298 defer func() {
7299 if err == io.EOF {
7300 err = io.ErrUnexpectedEOF
7301 }
7302 }()
7303
7304 if maj != cbg.MajMap {
7305 return fmt.Errorf("cbor input should be of type map")
7306 }
7307
7308 if extra > cbg.MaxLength {
7309 return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra)
7310 }
7311
7312 n := extra
7313
7314 nameBuf := make([]byte, 6)
7315 for i := uint64(0); i < n; i++ {
7316 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7317 if err != nil {
7318 return err
7319 }
7320
7321 if !ok {
7322 // Field doesn't exist on this type, so ignore it
7323 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7324 return err
7325 }
7326 continue
7327 }
7328
7329 switch string(nameBuf[:nameLen]) {
7330 // t.Sha (string) (string)
7331 case "sha":
7332
7333 {
7334 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7335 if err != nil {
7336 return err
7337 }
7338
7339 t.Sha = string(sval)
7340 }
7341 // t.Repo (string) (string)
7342 case "repo":
7343
7344 {
7345 b, err := cr.ReadByte()
7346 if err != nil {
7347 return err
7348 }
7349 if b != cbg.CborNull[0] {
7350 if err := cr.UnreadByte(); err != nil {
7351 return err
7352 }
7353
7354 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7355 if err != nil {
7356 return err
7357 }
7358
7359 t.Repo = (*string)(&sval)
7360 }
7361 }
7362 // t.Branch (string) (string)
7363 case "branch":
7364
7365 {
7366 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7367 if err != nil {
7368 return err
7369 }
7370
7371 t.Branch = string(sval)
7372 }
7373
7374 default:
7375 // Field doesn't exist on this type, so ignore it
7376 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7377 return err
7378 }
7379 }
7380 }
7381
7382 return nil
7383}
7384func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error {
7385 if t == nil {
7386 _, err := w.Write(cbg.CborNull)
7387 return err
7388 }
7389
7390 cw := cbg.NewCborWriter(w)
7391
7392 if _, err := cw.Write([]byte{163}); err != nil {
7393 return err
7394 }
7395
7396 // t.Pull (string) (string)
7397 if len("pull") > 1000000 {
7398 return xerrors.Errorf("Value in field \"pull\" was too long")
7399 }
7400
7401 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
7402 return err
7403 }
7404 if _, err := cw.WriteString(string("pull")); err != nil {
7405 return err
7406 }
7407
7408 if len(t.Pull) > 1000000 {
7409 return xerrors.Errorf("Value in field t.Pull was too long")
7410 }
7411
7412 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
7413 return err
7414 }
7415 if _, err := cw.WriteString(string(t.Pull)); err != nil {
7416 return err
7417 }
7418
7419 // t.LexiconTypeID (string) (string)
7420 if len("$type") > 1000000 {
7421 return xerrors.Errorf("Value in field \"$type\" was too long")
7422 }
7423
7424 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7425 return err
7426 }
7427 if _, err := cw.WriteString(string("$type")); err != nil {
7428 return err
7429 }
7430
7431 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil {
7432 return err
7433 }
7434 if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil {
7435 return err
7436 }
7437
7438 // t.Status (string) (string)
7439 if len("status") > 1000000 {
7440 return xerrors.Errorf("Value in field \"status\" was too long")
7441 }
7442
7443 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
7444 return err
7445 }
7446 if _, err := cw.WriteString(string("status")); err != nil {
7447 return err
7448 }
7449
7450 if len(t.Status) > 1000000 {
7451 return xerrors.Errorf("Value in field t.Status was too long")
7452 }
7453
7454 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
7455 return err
7456 }
7457 if _, err := cw.WriteString(string(t.Status)); err != nil {
7458 return err
7459 }
7460 return nil
7461}
7462
7463func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) {
7464 *t = RepoPullStatus{}
7465
7466 cr := cbg.NewCborReader(r)
7467
7468 maj, extra, err := cr.ReadHeader()
7469 if err != nil {
7470 return err
7471 }
7472 defer func() {
7473 if err == io.EOF {
7474 err = io.ErrUnexpectedEOF
7475 }
7476 }()
7477
7478 if maj != cbg.MajMap {
7479 return fmt.Errorf("cbor input should be of type map")
7480 }
7481
7482 if extra > cbg.MaxLength {
7483 return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra)
7484 }
7485
7486 n := extra
7487
7488 nameBuf := make([]byte, 6)
7489 for i := uint64(0); i < n; i++ {
7490 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7491 if err != nil {
7492 return err
7493 }
7494
7495 if !ok {
7496 // Field doesn't exist on this type, so ignore it
7497 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7498 return err
7499 }
7500 continue
7501 }
7502
7503 switch string(nameBuf[:nameLen]) {
7504 // t.Pull (string) (string)
7505 case "pull":
7506
7507 {
7508 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7509 if err != nil {
7510 return err
7511 }
7512
7513 t.Pull = string(sval)
7514 }
7515 // t.LexiconTypeID (string) (string)
7516 case "$type":
7517
7518 {
7519 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7520 if err != nil {
7521 return err
7522 }
7523
7524 t.LexiconTypeID = string(sval)
7525 }
7526 // t.Status (string) (string)
7527 case "status":
7528
7529 {
7530 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7531 if err != nil {
7532 return err
7533 }
7534
7535 t.Status = string(sval)
7536 }
7537
7538 default:
7539 // Field doesn't exist on this type, so ignore it
7540 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7541 return err
7542 }
7543 }
7544 }
7545
7546 return nil
7547}
7548func (t *Spindle) MarshalCBOR(w io.Writer) error {
7549 if t == nil {
7550 _, err := w.Write(cbg.CborNull)
7551 return err
7552 }
7553
7554 cw := cbg.NewCborWriter(w)
7555
7556 if _, err := cw.Write([]byte{162}); err != nil {
7557 return err
7558 }
7559
7560 // t.LexiconTypeID (string) (string)
7561 if len("$type") > 1000000 {
7562 return xerrors.Errorf("Value in field \"$type\" was too long")
7563 }
7564
7565 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7566 return err
7567 }
7568 if _, err := cw.WriteString(string("$type")); err != nil {
7569 return err
7570 }
7571
7572 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle"))); err != nil {
7573 return err
7574 }
7575 if _, err := cw.WriteString(string("sh.tangled.spindle")); err != nil {
7576 return err
7577 }
7578
7579 // t.CreatedAt (string) (string)
7580 if len("createdAt") > 1000000 {
7581 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7582 }
7583
7584 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7585 return err
7586 }
7587 if _, err := cw.WriteString(string("createdAt")); err != nil {
7588 return err
7589 }
7590
7591 if len(t.CreatedAt) > 1000000 {
7592 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7593 }
7594
7595 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7596 return err
7597 }
7598 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7599 return err
7600 }
7601 return nil
7602}
7603
7604func (t *Spindle) UnmarshalCBOR(r io.Reader) (err error) {
7605 *t = Spindle{}
7606
7607 cr := cbg.NewCborReader(r)
7608
7609 maj, extra, err := cr.ReadHeader()
7610 if err != nil {
7611 return err
7612 }
7613 defer func() {
7614 if err == io.EOF {
7615 err = io.ErrUnexpectedEOF
7616 }
7617 }()
7618
7619 if maj != cbg.MajMap {
7620 return fmt.Errorf("cbor input should be of type map")
7621 }
7622
7623 if extra > cbg.MaxLength {
7624 return fmt.Errorf("Spindle: map struct too large (%d)", extra)
7625 }
7626
7627 n := extra
7628
7629 nameBuf := make([]byte, 9)
7630 for i := uint64(0); i < n; i++ {
7631 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7632 if err != nil {
7633 return err
7634 }
7635
7636 if !ok {
7637 // Field doesn't exist on this type, so ignore it
7638 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7639 return err
7640 }
7641 continue
7642 }
7643
7644 switch string(nameBuf[:nameLen]) {
7645 // t.LexiconTypeID (string) (string)
7646 case "$type":
7647
7648 {
7649 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7650 if err != nil {
7651 return err
7652 }
7653
7654 t.LexiconTypeID = string(sval)
7655 }
7656 // t.CreatedAt (string) (string)
7657 case "createdAt":
7658
7659 {
7660 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7661 if err != nil {
7662 return err
7663 }
7664
7665 t.CreatedAt = string(sval)
7666 }
7667
7668 default:
7669 // Field doesn't exist on this type, so ignore it
7670 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7671 return err
7672 }
7673 }
7674 }
7675
7676 return nil
7677}
7678func (t *SpindleMember) MarshalCBOR(w io.Writer) error {
7679 if t == nil {
7680 _, err := w.Write(cbg.CborNull)
7681 return err
7682 }
7683
7684 cw := cbg.NewCborWriter(w)
7685
7686 if _, err := cw.Write([]byte{164}); err != nil {
7687 return err
7688 }
7689
7690 // t.LexiconTypeID (string) (string)
7691 if len("$type") > 1000000 {
7692 return xerrors.Errorf("Value in field \"$type\" was too long")
7693 }
7694
7695 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7696 return err
7697 }
7698 if _, err := cw.WriteString(string("$type")); err != nil {
7699 return err
7700 }
7701
7702 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle.member"))); err != nil {
7703 return err
7704 }
7705 if _, err := cw.WriteString(string("sh.tangled.spindle.member")); err != nil {
7706 return err
7707 }
7708
7709 // t.Subject (string) (string)
7710 if len("subject") > 1000000 {
7711 return xerrors.Errorf("Value in field \"subject\" was too long")
7712 }
7713
7714 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
7715 return err
7716 }
7717 if _, err := cw.WriteString(string("subject")); err != nil {
7718 return err
7719 }
7720
7721 if len(t.Subject) > 1000000 {
7722 return xerrors.Errorf("Value in field t.Subject was too long")
7723 }
7724
7725 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
7726 return err
7727 }
7728 if _, err := cw.WriteString(string(t.Subject)); err != nil {
7729 return err
7730 }
7731
7732 // t.Instance (string) (string)
7733 if len("instance") > 1000000 {
7734 return xerrors.Errorf("Value in field \"instance\" was too long")
7735 }
7736
7737 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("instance"))); err != nil {
7738 return err
7739 }
7740 if _, err := cw.WriteString(string("instance")); err != nil {
7741 return err
7742 }
7743
7744 if len(t.Instance) > 1000000 {
7745 return xerrors.Errorf("Value in field t.Instance was too long")
7746 }
7747
7748 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Instance))); err != nil {
7749 return err
7750 }
7751 if _, err := cw.WriteString(string(t.Instance)); err != nil {
7752 return err
7753 }
7754
7755 // t.CreatedAt (string) (string)
7756 if len("createdAt") > 1000000 {
7757 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7758 }
7759
7760 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7761 return err
7762 }
7763 if _, err := cw.WriteString(string("createdAt")); err != nil {
7764 return err
7765 }
7766
7767 if len(t.CreatedAt) > 1000000 {
7768 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7769 }
7770
7771 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7772 return err
7773 }
7774 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7775 return err
7776 }
7777 return nil
7778}
7779
7780func (t *SpindleMember) UnmarshalCBOR(r io.Reader) (err error) {
7781 *t = SpindleMember{}
7782
7783 cr := cbg.NewCborReader(r)
7784
7785 maj, extra, err := cr.ReadHeader()
7786 if err != nil {
7787 return err
7788 }
7789 defer func() {
7790 if err == io.EOF {
7791 err = io.ErrUnexpectedEOF
7792 }
7793 }()
7794
7795 if maj != cbg.MajMap {
7796 return fmt.Errorf("cbor input should be of type map")
7797 }
7798
7799 if extra > cbg.MaxLength {
7800 return fmt.Errorf("SpindleMember: map struct too large (%d)", extra)
7801 }
7802
7803 n := extra
7804
7805 nameBuf := make([]byte, 9)
7806 for i := uint64(0); i < n; i++ {
7807 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7808 if err != nil {
7809 return err
7810 }
7811
7812 if !ok {
7813 // Field doesn't exist on this type, so ignore it
7814 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7815 return err
7816 }
7817 continue
7818 }
7819
7820 switch string(nameBuf[:nameLen]) {
7821 // t.LexiconTypeID (string) (string)
7822 case "$type":
7823
7824 {
7825 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7826 if err != nil {
7827 return err
7828 }
7829
7830 t.LexiconTypeID = string(sval)
7831 }
7832 // t.Subject (string) (string)
7833 case "subject":
7834
7835 {
7836 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7837 if err != nil {
7838 return err
7839 }
7840
7841 t.Subject = string(sval)
7842 }
7843 // t.Instance (string) (string)
7844 case "instance":
7845
7846 {
7847 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7848 if err != nil {
7849 return err
7850 }
7851
7852 t.Instance = string(sval)
7853 }
7854 // t.CreatedAt (string) (string)
7855 case "createdAt":
7856
7857 {
7858 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7859 if err != nil {
7860 return err
7861 }
7862
7863 t.CreatedAt = string(sval)
7864 }
7865
7866 default:
7867 // Field doesn't exist on this type, so ignore it
7868 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7869 return err
7870 }
7871 }
7872 }
7873
7874 return nil
7875}
7876func (t *String) MarshalCBOR(w io.Writer) error {
7877 if t == nil {
7878 _, err := w.Write(cbg.CborNull)
7879 return err
7880 }
7881
7882 cw := cbg.NewCborWriter(w)
7883
7884 if _, err := cw.Write([]byte{165}); err != nil {
7885 return err
7886 }
7887
7888 // t.LexiconTypeID (string) (string)
7889 if len("$type") > 1000000 {
7890 return xerrors.Errorf("Value in field \"$type\" was too long")
7891 }
7892
7893 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7894 return err
7895 }
7896 if _, err := cw.WriteString(string("$type")); err != nil {
7897 return err
7898 }
7899
7900 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.string"))); err != nil {
7901 return err
7902 }
7903 if _, err := cw.WriteString(string("sh.tangled.string")); err != nil {
7904 return err
7905 }
7906
7907 // t.Contents (string) (string)
7908 if len("contents") > 1000000 {
7909 return xerrors.Errorf("Value in field \"contents\" was too long")
7910 }
7911
7912 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("contents"))); err != nil {
7913 return err
7914 }
7915 if _, err := cw.WriteString(string("contents")); err != nil {
7916 return err
7917 }
7918
7919 if len(t.Contents) > 1000000 {
7920 return xerrors.Errorf("Value in field t.Contents was too long")
7921 }
7922
7923 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Contents))); err != nil {
7924 return err
7925 }
7926 if _, err := cw.WriteString(string(t.Contents)); err != nil {
7927 return err
7928 }
7929
7930 // t.Filename (string) (string)
7931 if len("filename") > 1000000 {
7932 return xerrors.Errorf("Value in field \"filename\" was too long")
7933 }
7934
7935 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("filename"))); err != nil {
7936 return err
7937 }
7938 if _, err := cw.WriteString(string("filename")); err != nil {
7939 return err
7940 }
7941
7942 if len(t.Filename) > 1000000 {
7943 return xerrors.Errorf("Value in field t.Filename was too long")
7944 }
7945
7946 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Filename))); err != nil {
7947 return err
7948 }
7949 if _, err := cw.WriteString(string(t.Filename)); err != nil {
7950 return err
7951 }
7952
7953 // t.CreatedAt (string) (string)
7954 if len("createdAt") > 1000000 {
7955 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7956 }
7957
7958 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7959 return err
7960 }
7961 if _, err := cw.WriteString(string("createdAt")); err != nil {
7962 return err
7963 }
7964
7965 if len(t.CreatedAt) > 1000000 {
7966 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7967 }
7968
7969 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7970 return err
7971 }
7972 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7973 return err
7974 }
7975
7976 // t.Description (string) (string)
7977 if len("description") > 1000000 {
7978 return xerrors.Errorf("Value in field \"description\" was too long")
7979 }
7980
7981 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
7982 return err
7983 }
7984 if _, err := cw.WriteString(string("description")); err != nil {
7985 return err
7986 }
7987
7988 if len(t.Description) > 1000000 {
7989 return xerrors.Errorf("Value in field t.Description was too long")
7990 }
7991
7992 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil {
7993 return err
7994 }
7995 if _, err := cw.WriteString(string(t.Description)); err != nil {
7996 return err
7997 }
7998 return nil
7999}
8000
8001func (t *String) UnmarshalCBOR(r io.Reader) (err error) {
8002 *t = String{}
8003
8004 cr := cbg.NewCborReader(r)
8005
8006 maj, extra, err := cr.ReadHeader()
8007 if err != nil {
8008 return err
8009 }
8010 defer func() {
8011 if err == io.EOF {
8012 err = io.ErrUnexpectedEOF
8013 }
8014 }()
8015
8016 if maj != cbg.MajMap {
8017 return fmt.Errorf("cbor input should be of type map")
8018 }
8019
8020 if extra > cbg.MaxLength {
8021 return fmt.Errorf("String: map struct too large (%d)", extra)
8022 }
8023
8024 n := extra
8025
8026 nameBuf := make([]byte, 11)
8027 for i := uint64(0); i < n; i++ {
8028 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8029 if err != nil {
8030 return err
8031 }
8032
8033 if !ok {
8034 // Field doesn't exist on this type, so ignore it
8035 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8036 return err
8037 }
8038 continue
8039 }
8040
8041 switch string(nameBuf[:nameLen]) {
8042 // t.LexiconTypeID (string) (string)
8043 case "$type":
8044
8045 {
8046 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8047 if err != nil {
8048 return err
8049 }
8050
8051 t.LexiconTypeID = string(sval)
8052 }
8053 // t.Contents (string) (string)
8054 case "contents":
8055
8056 {
8057 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8058 if err != nil {
8059 return err
8060 }
8061
8062 t.Contents = string(sval)
8063 }
8064 // t.Filename (string) (string)
8065 case "filename":
8066
8067 {
8068 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8069 if err != nil {
8070 return err
8071 }
8072
8073 t.Filename = string(sval)
8074 }
8075 // t.CreatedAt (string) (string)
8076 case "createdAt":
8077
8078 {
8079 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8080 if err != nil {
8081 return err
8082 }
8083
8084 t.CreatedAt = string(sval)
8085 }
8086 // t.Description (string) (string)
8087 case "description":
8088
8089 {
8090 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8091 if err != nil {
8092 return err
8093 }
8094
8095 t.Description = string(sval)
8096 }
8097
8098 default:
8099 // Field doesn't exist on this type, so ignore it
8100 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8101 return err
8102 }
8103 }
8104 }
8105
8106 return nil
8107}