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