sanin.dev
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 := 6
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.CreatedAt (string) (string)
5646 if len("createdAt") > 1000000 {
5647 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5648 }
5649
5650 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5651 return err
5652 }
5653 if _, err := cw.WriteString(string("createdAt")); err != nil {
5654 return err
5655 }
5656
5657 if len(t.CreatedAt) > 1000000 {
5658 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5659 }
5660
5661 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5662 return err
5663 }
5664 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5665 return err
5666 }
5667 return nil
5668}
5669
5670func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) {
5671 *t = RepoIssue{}
5672
5673 cr := cbg.NewCborReader(r)
5674
5675 maj, extra, err := cr.ReadHeader()
5676 if err != nil {
5677 return err
5678 }
5679 defer func() {
5680 if err == io.EOF {
5681 err = io.ErrUnexpectedEOF
5682 }
5683 }()
5684
5685 if maj != cbg.MajMap {
5686 return fmt.Errorf("cbor input should be of type map")
5687 }
5688
5689 if extra > cbg.MaxLength {
5690 return fmt.Errorf("RepoIssue: map struct too large (%d)", extra)
5691 }
5692
5693 n := extra
5694
5695 nameBuf := make([]byte, 9)
5696 for i := uint64(0); i < n; i++ {
5697 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5698 if err != nil {
5699 return err
5700 }
5701
5702 if !ok {
5703 // Field doesn't exist on this type, so ignore it
5704 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5705 return err
5706 }
5707 continue
5708 }
5709
5710 switch string(nameBuf[:nameLen]) {
5711 // t.Body (string) (string)
5712 case "body":
5713
5714 {
5715 b, err := cr.ReadByte()
5716 if err != nil {
5717 return err
5718 }
5719 if b != cbg.CborNull[0] {
5720 if err := cr.UnreadByte(); err != nil {
5721 return err
5722 }
5723
5724 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5725 if err != nil {
5726 return err
5727 }
5728
5729 t.Body = (*string)(&sval)
5730 }
5731 }
5732 // t.Repo (string) (string)
5733 case "repo":
5734
5735 {
5736 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5737 if err != nil {
5738 return err
5739 }
5740
5741 t.Repo = string(sval)
5742 }
5743 // t.LexiconTypeID (string) (string)
5744 case "$type":
5745
5746 {
5747 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5748 if err != nil {
5749 return err
5750 }
5751
5752 t.LexiconTypeID = string(sval)
5753 }
5754 // t.Owner (string) (string)
5755 case "owner":
5756
5757 {
5758 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5759 if err != nil {
5760 return err
5761 }
5762
5763 t.Owner = string(sval)
5764 }
5765 // t.Title (string) (string)
5766 case "title":
5767
5768 {
5769 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5770 if err != nil {
5771 return err
5772 }
5773
5774 t.Title = string(sval)
5775 }
5776 // t.CreatedAt (string) (string)
5777 case "createdAt":
5778
5779 {
5780 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5781 if err != nil {
5782 return err
5783 }
5784
5785 t.CreatedAt = string(sval)
5786 }
5787
5788 default:
5789 // Field doesn't exist on this type, so ignore it
5790 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5791 return err
5792 }
5793 }
5794 }
5795
5796 return nil
5797}
5798func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error {
5799 if t == nil {
5800 _, err := w.Write(cbg.CborNull)
5801 return err
5802 }
5803
5804 cw := cbg.NewCborWriter(w)
5805 fieldCount := 6
5806
5807 if t.Owner == nil {
5808 fieldCount--
5809 }
5810
5811 if t.Repo == nil {
5812 fieldCount--
5813 }
5814
5815 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5816 return err
5817 }
5818
5819 // t.Body (string) (string)
5820 if len("body") > 1000000 {
5821 return xerrors.Errorf("Value in field \"body\" was too long")
5822 }
5823
5824 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
5825 return err
5826 }
5827 if _, err := cw.WriteString(string("body")); err != nil {
5828 return err
5829 }
5830
5831 if len(t.Body) > 1000000 {
5832 return xerrors.Errorf("Value in field t.Body was too long")
5833 }
5834
5835 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
5836 return err
5837 }
5838 if _, err := cw.WriteString(string(t.Body)); err != nil {
5839 return err
5840 }
5841
5842 // t.Repo (string) (string)
5843 if t.Repo != nil {
5844
5845 if len("repo") > 1000000 {
5846 return xerrors.Errorf("Value in field \"repo\" was too long")
5847 }
5848
5849 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5850 return err
5851 }
5852 if _, err := cw.WriteString(string("repo")); err != nil {
5853 return err
5854 }
5855
5856 if t.Repo == nil {
5857 if _, err := cw.Write(cbg.CborNull); err != nil {
5858 return err
5859 }
5860 } else {
5861 if len(*t.Repo) > 1000000 {
5862 return xerrors.Errorf("Value in field t.Repo was too long")
5863 }
5864
5865 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
5866 return err
5867 }
5868 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
5869 return err
5870 }
5871 }
5872 }
5873
5874 // t.LexiconTypeID (string) (string)
5875 if len("$type") > 1000000 {
5876 return xerrors.Errorf("Value in field \"$type\" was too long")
5877 }
5878
5879 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5880 return err
5881 }
5882 if _, err := cw.WriteString(string("$type")); err != nil {
5883 return err
5884 }
5885
5886 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil {
5887 return err
5888 }
5889 if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil {
5890 return err
5891 }
5892
5893 // t.Issue (string) (string)
5894 if len("issue") > 1000000 {
5895 return xerrors.Errorf("Value in field \"issue\" was too long")
5896 }
5897
5898 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
5899 return err
5900 }
5901 if _, err := cw.WriteString(string("issue")); err != nil {
5902 return err
5903 }
5904
5905 if len(t.Issue) > 1000000 {
5906 return xerrors.Errorf("Value in field t.Issue was too long")
5907 }
5908
5909 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
5910 return err
5911 }
5912 if _, err := cw.WriteString(string(t.Issue)); err != nil {
5913 return err
5914 }
5915
5916 // t.Owner (string) (string)
5917 if t.Owner != nil {
5918
5919 if len("owner") > 1000000 {
5920 return xerrors.Errorf("Value in field \"owner\" was too long")
5921 }
5922
5923 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
5924 return err
5925 }
5926 if _, err := cw.WriteString(string("owner")); err != nil {
5927 return err
5928 }
5929
5930 if t.Owner == nil {
5931 if _, err := cw.Write(cbg.CborNull); err != nil {
5932 return err
5933 }
5934 } else {
5935 if len(*t.Owner) > 1000000 {
5936 return xerrors.Errorf("Value in field t.Owner was too long")
5937 }
5938
5939 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Owner))); err != nil {
5940 return err
5941 }
5942 if _, err := cw.WriteString(string(*t.Owner)); err != nil {
5943 return err
5944 }
5945 }
5946 }
5947
5948 // t.CreatedAt (string) (string)
5949 if len("createdAt") > 1000000 {
5950 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5951 }
5952
5953 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5954 return err
5955 }
5956 if _, err := cw.WriteString(string("createdAt")); err != nil {
5957 return err
5958 }
5959
5960 if len(t.CreatedAt) > 1000000 {
5961 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5962 }
5963
5964 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5965 return err
5966 }
5967 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5968 return err
5969 }
5970 return nil
5971}
5972
5973func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) {
5974 *t = RepoIssueComment{}
5975
5976 cr := cbg.NewCborReader(r)
5977
5978 maj, extra, err := cr.ReadHeader()
5979 if err != nil {
5980 return err
5981 }
5982 defer func() {
5983 if err == io.EOF {
5984 err = io.ErrUnexpectedEOF
5985 }
5986 }()
5987
5988 if maj != cbg.MajMap {
5989 return fmt.Errorf("cbor input should be of type map")
5990 }
5991
5992 if extra > cbg.MaxLength {
5993 return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra)
5994 }
5995
5996 n := extra
5997
5998 nameBuf := make([]byte, 9)
5999 for i := uint64(0); i < n; i++ {
6000 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6001 if err != nil {
6002 return err
6003 }
6004
6005 if !ok {
6006 // Field doesn't exist on this type, so ignore it
6007 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6008 return err
6009 }
6010 continue
6011 }
6012
6013 switch string(nameBuf[:nameLen]) {
6014 // t.Body (string) (string)
6015 case "body":
6016
6017 {
6018 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6019 if err != nil {
6020 return err
6021 }
6022
6023 t.Body = string(sval)
6024 }
6025 // t.Repo (string) (string)
6026 case "repo":
6027
6028 {
6029 b, err := cr.ReadByte()
6030 if err != nil {
6031 return err
6032 }
6033 if b != cbg.CborNull[0] {
6034 if err := cr.UnreadByte(); err != nil {
6035 return err
6036 }
6037
6038 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6039 if err != nil {
6040 return err
6041 }
6042
6043 t.Repo = (*string)(&sval)
6044 }
6045 }
6046 // t.LexiconTypeID (string) (string)
6047 case "$type":
6048
6049 {
6050 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6051 if err != nil {
6052 return err
6053 }
6054
6055 t.LexiconTypeID = string(sval)
6056 }
6057 // t.Issue (string) (string)
6058 case "issue":
6059
6060 {
6061 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6062 if err != nil {
6063 return err
6064 }
6065
6066 t.Issue = string(sval)
6067 }
6068 // t.Owner (string) (string)
6069 case "owner":
6070
6071 {
6072 b, err := cr.ReadByte()
6073 if err != nil {
6074 return err
6075 }
6076 if b != cbg.CborNull[0] {
6077 if err := cr.UnreadByte(); err != nil {
6078 return err
6079 }
6080
6081 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6082 if err != nil {
6083 return err
6084 }
6085
6086 t.Owner = (*string)(&sval)
6087 }
6088 }
6089 // t.CreatedAt (string) (string)
6090 case "createdAt":
6091
6092 {
6093 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6094 if err != nil {
6095 return err
6096 }
6097
6098 t.CreatedAt = string(sval)
6099 }
6100
6101 default:
6102 // Field doesn't exist on this type, so ignore it
6103 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6104 return err
6105 }
6106 }
6107 }
6108
6109 return nil
6110}
6111func (t *RepoIssueState) MarshalCBOR(w io.Writer) error {
6112 if t == nil {
6113 _, err := w.Write(cbg.CborNull)
6114 return err
6115 }
6116
6117 cw := cbg.NewCborWriter(w)
6118
6119 if _, err := cw.Write([]byte{163}); err != nil {
6120 return err
6121 }
6122
6123 // t.LexiconTypeID (string) (string)
6124 if len("$type") > 1000000 {
6125 return xerrors.Errorf("Value in field \"$type\" was too long")
6126 }
6127
6128 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6129 return err
6130 }
6131 if _, err := cw.WriteString(string("$type")); err != nil {
6132 return err
6133 }
6134
6135 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil {
6136 return err
6137 }
6138 if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil {
6139 return err
6140 }
6141
6142 // t.Issue (string) (string)
6143 if len("issue") > 1000000 {
6144 return xerrors.Errorf("Value in field \"issue\" was too long")
6145 }
6146
6147 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
6148 return err
6149 }
6150 if _, err := cw.WriteString(string("issue")); err != nil {
6151 return err
6152 }
6153
6154 if len(t.Issue) > 1000000 {
6155 return xerrors.Errorf("Value in field t.Issue was too long")
6156 }
6157
6158 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
6159 return err
6160 }
6161 if _, err := cw.WriteString(string(t.Issue)); err != nil {
6162 return err
6163 }
6164
6165 // t.State (string) (string)
6166 if len("state") > 1000000 {
6167 return xerrors.Errorf("Value in field \"state\" was too long")
6168 }
6169
6170 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil {
6171 return err
6172 }
6173 if _, err := cw.WriteString(string("state")); err != nil {
6174 return err
6175 }
6176
6177 if len(t.State) > 1000000 {
6178 return xerrors.Errorf("Value in field t.State was too long")
6179 }
6180
6181 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil {
6182 return err
6183 }
6184 if _, err := cw.WriteString(string(t.State)); err != nil {
6185 return err
6186 }
6187 return nil
6188}
6189
6190func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) {
6191 *t = RepoIssueState{}
6192
6193 cr := cbg.NewCborReader(r)
6194
6195 maj, extra, err := cr.ReadHeader()
6196 if err != nil {
6197 return err
6198 }
6199 defer func() {
6200 if err == io.EOF {
6201 err = io.ErrUnexpectedEOF
6202 }
6203 }()
6204
6205 if maj != cbg.MajMap {
6206 return fmt.Errorf("cbor input should be of type map")
6207 }
6208
6209 if extra > cbg.MaxLength {
6210 return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra)
6211 }
6212
6213 n := extra
6214
6215 nameBuf := make([]byte, 5)
6216 for i := uint64(0); i < n; i++ {
6217 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6218 if err != nil {
6219 return err
6220 }
6221
6222 if !ok {
6223 // Field doesn't exist on this type, so ignore it
6224 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6225 return err
6226 }
6227 continue
6228 }
6229
6230 switch string(nameBuf[:nameLen]) {
6231 // t.LexiconTypeID (string) (string)
6232 case "$type":
6233
6234 {
6235 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6236 if err != nil {
6237 return err
6238 }
6239
6240 t.LexiconTypeID = string(sval)
6241 }
6242 // t.Issue (string) (string)
6243 case "issue":
6244
6245 {
6246 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6247 if err != nil {
6248 return err
6249 }
6250
6251 t.Issue = string(sval)
6252 }
6253 // t.State (string) (string)
6254 case "state":
6255
6256 {
6257 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6258 if err != nil {
6259 return err
6260 }
6261
6262 t.State = string(sval)
6263 }
6264
6265 default:
6266 // Field doesn't exist on this type, so ignore it
6267 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6268 return err
6269 }
6270 }
6271 }
6272
6273 return nil
6274}
6275func (t *RepoPull) MarshalCBOR(w io.Writer) error {
6276 if t == nil {
6277 _, err := w.Write(cbg.CborNull)
6278 return err
6279 }
6280
6281 cw := cbg.NewCborWriter(w)
6282 fieldCount := 9
6283
6284 if t.Body == nil {
6285 fieldCount--
6286 }
6287
6288 if t.Source == nil {
6289 fieldCount--
6290 }
6291
6292 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6293 return err
6294 }
6295
6296 // t.Body (string) (string)
6297 if t.Body != nil {
6298
6299 if len("body") > 1000000 {
6300 return xerrors.Errorf("Value in field \"body\" was too long")
6301 }
6302
6303 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
6304 return err
6305 }
6306 if _, err := cw.WriteString(string("body")); err != nil {
6307 return err
6308 }
6309
6310 if t.Body == nil {
6311 if _, err := cw.Write(cbg.CborNull); err != nil {
6312 return err
6313 }
6314 } else {
6315 if len(*t.Body) > 1000000 {
6316 return xerrors.Errorf("Value in field t.Body was too long")
6317 }
6318
6319 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
6320 return err
6321 }
6322 if _, err := cw.WriteString(string(*t.Body)); err != nil {
6323 return err
6324 }
6325 }
6326 }
6327
6328 // t.LexiconTypeID (string) (string)
6329 if len("$type") > 1000000 {
6330 return xerrors.Errorf("Value in field \"$type\" was too long")
6331 }
6332
6333 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6334 return err
6335 }
6336 if _, err := cw.WriteString(string("$type")); err != nil {
6337 return err
6338 }
6339
6340 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil {
6341 return err
6342 }
6343 if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil {
6344 return err
6345 }
6346
6347 // t.Patch (string) (string)
6348 if len("patch") > 1000000 {
6349 return xerrors.Errorf("Value in field \"patch\" was too long")
6350 }
6351
6352 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil {
6353 return err
6354 }
6355 if _, err := cw.WriteString(string("patch")); err != nil {
6356 return err
6357 }
6358
6359 if len(t.Patch) > 1000000 {
6360 return xerrors.Errorf("Value in field t.Patch was too long")
6361 }
6362
6363 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Patch))); err != nil {
6364 return err
6365 }
6366 if _, err := cw.WriteString(string(t.Patch)); err != nil {
6367 return err
6368 }
6369
6370 // t.Title (string) (string)
6371 if len("title") > 1000000 {
6372 return xerrors.Errorf("Value in field \"title\" was too long")
6373 }
6374
6375 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
6376 return err
6377 }
6378 if _, err := cw.WriteString(string("title")); err != nil {
6379 return err
6380 }
6381
6382 if len(t.Title) > 1000000 {
6383 return xerrors.Errorf("Value in field t.Title was too long")
6384 }
6385
6386 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
6387 return err
6388 }
6389 if _, err := cw.WriteString(string(t.Title)); err != nil {
6390 return err
6391 }
6392
6393 // t.PullId (int64) (int64)
6394 if len("pullId") > 1000000 {
6395 return xerrors.Errorf("Value in field \"pullId\" was too long")
6396 }
6397
6398 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullId"))); err != nil {
6399 return err
6400 }
6401 if _, err := cw.WriteString(string("pullId")); err != nil {
6402 return err
6403 }
6404
6405 if t.PullId >= 0 {
6406 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.PullId)); err != nil {
6407 return err
6408 }
6409 } else {
6410 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.PullId-1)); err != nil {
6411 return err
6412 }
6413 }
6414
6415 // t.Source (tangled.RepoPull_Source) (struct)
6416 if t.Source != nil {
6417
6418 if len("source") > 1000000 {
6419 return xerrors.Errorf("Value in field \"source\" was too long")
6420 }
6421
6422 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
6423 return err
6424 }
6425 if _, err := cw.WriteString(string("source")); err != nil {
6426 return err
6427 }
6428
6429 if err := t.Source.MarshalCBOR(cw); err != nil {
6430 return err
6431 }
6432 }
6433
6434 // t.CreatedAt (string) (string)
6435 if len("createdAt") > 1000000 {
6436 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6437 }
6438
6439 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6440 return err
6441 }
6442 if _, err := cw.WriteString(string("createdAt")); err != nil {
6443 return err
6444 }
6445
6446 if len(t.CreatedAt) > 1000000 {
6447 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6448 }
6449
6450 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6451 return err
6452 }
6453 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6454 return err
6455 }
6456
6457 // t.TargetRepo (string) (string)
6458 if len("targetRepo") > 1000000 {
6459 return xerrors.Errorf("Value in field \"targetRepo\" was too long")
6460 }
6461
6462 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetRepo"))); err != nil {
6463 return err
6464 }
6465 if _, err := cw.WriteString(string("targetRepo")); err != nil {
6466 return err
6467 }
6468
6469 if len(t.TargetRepo) > 1000000 {
6470 return xerrors.Errorf("Value in field t.TargetRepo was too long")
6471 }
6472
6473 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetRepo))); err != nil {
6474 return err
6475 }
6476 if _, err := cw.WriteString(string(t.TargetRepo)); err != nil {
6477 return err
6478 }
6479
6480 // t.TargetBranch (string) (string)
6481 if len("targetBranch") > 1000000 {
6482 return xerrors.Errorf("Value in field \"targetBranch\" was too long")
6483 }
6484
6485 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil {
6486 return err
6487 }
6488 if _, err := cw.WriteString(string("targetBranch")); err != nil {
6489 return err
6490 }
6491
6492 if len(t.TargetBranch) > 1000000 {
6493 return xerrors.Errorf("Value in field t.TargetBranch was too long")
6494 }
6495
6496 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil {
6497 return err
6498 }
6499 if _, err := cw.WriteString(string(t.TargetBranch)); err != nil {
6500 return err
6501 }
6502 return nil
6503}
6504
6505func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) {
6506 *t = RepoPull{}
6507
6508 cr := cbg.NewCborReader(r)
6509
6510 maj, extra, err := cr.ReadHeader()
6511 if err != nil {
6512 return err
6513 }
6514 defer func() {
6515 if err == io.EOF {
6516 err = io.ErrUnexpectedEOF
6517 }
6518 }()
6519
6520 if maj != cbg.MajMap {
6521 return fmt.Errorf("cbor input should be of type map")
6522 }
6523
6524 if extra > cbg.MaxLength {
6525 return fmt.Errorf("RepoPull: map struct too large (%d)", extra)
6526 }
6527
6528 n := extra
6529
6530 nameBuf := make([]byte, 12)
6531 for i := uint64(0); i < n; i++ {
6532 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6533 if err != nil {
6534 return err
6535 }
6536
6537 if !ok {
6538 // Field doesn't exist on this type, so ignore it
6539 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6540 return err
6541 }
6542 continue
6543 }
6544
6545 switch string(nameBuf[:nameLen]) {
6546 // t.Body (string) (string)
6547 case "body":
6548
6549 {
6550 b, err := cr.ReadByte()
6551 if err != nil {
6552 return err
6553 }
6554 if b != cbg.CborNull[0] {
6555 if err := cr.UnreadByte(); err != nil {
6556 return err
6557 }
6558
6559 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6560 if err != nil {
6561 return err
6562 }
6563
6564 t.Body = (*string)(&sval)
6565 }
6566 }
6567 // t.LexiconTypeID (string) (string)
6568 case "$type":
6569
6570 {
6571 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6572 if err != nil {
6573 return err
6574 }
6575
6576 t.LexiconTypeID = string(sval)
6577 }
6578 // t.Patch (string) (string)
6579 case "patch":
6580
6581 {
6582 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6583 if err != nil {
6584 return err
6585 }
6586
6587 t.Patch = string(sval)
6588 }
6589 // t.Title (string) (string)
6590 case "title":
6591
6592 {
6593 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6594 if err != nil {
6595 return err
6596 }
6597
6598 t.Title = string(sval)
6599 }
6600 // t.PullId (int64) (int64)
6601 case "pullId":
6602 {
6603 maj, extra, err := cr.ReadHeader()
6604 if err != nil {
6605 return err
6606 }
6607 var extraI int64
6608 switch maj {
6609 case cbg.MajUnsignedInt:
6610 extraI = int64(extra)
6611 if extraI < 0 {
6612 return fmt.Errorf("int64 positive overflow")
6613 }
6614 case cbg.MajNegativeInt:
6615 extraI = int64(extra)
6616 if extraI < 0 {
6617 return fmt.Errorf("int64 negative overflow")
6618 }
6619 extraI = -1 - extraI
6620 default:
6621 return fmt.Errorf("wrong type for int64 field: %d", maj)
6622 }
6623
6624 t.PullId = int64(extraI)
6625 }
6626 // t.Source (tangled.RepoPull_Source) (struct)
6627 case "source":
6628
6629 {
6630
6631 b, err := cr.ReadByte()
6632 if err != nil {
6633 return err
6634 }
6635 if b != cbg.CborNull[0] {
6636 if err := cr.UnreadByte(); err != nil {
6637 return err
6638 }
6639 t.Source = new(RepoPull_Source)
6640 if err := t.Source.UnmarshalCBOR(cr); err != nil {
6641 return xerrors.Errorf("unmarshaling t.Source pointer: %w", err)
6642 }
6643 }
6644
6645 }
6646 // t.CreatedAt (string) (string)
6647 case "createdAt":
6648
6649 {
6650 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6651 if err != nil {
6652 return err
6653 }
6654
6655 t.CreatedAt = string(sval)
6656 }
6657 // t.TargetRepo (string) (string)
6658 case "targetRepo":
6659
6660 {
6661 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6662 if err != nil {
6663 return err
6664 }
6665
6666 t.TargetRepo = string(sval)
6667 }
6668 // t.TargetBranch (string) (string)
6669 case "targetBranch":
6670
6671 {
6672 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6673 if err != nil {
6674 return err
6675 }
6676
6677 t.TargetBranch = string(sval)
6678 }
6679
6680 default:
6681 // Field doesn't exist on this type, so ignore it
6682 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6683 return err
6684 }
6685 }
6686 }
6687
6688 return nil
6689}
6690func (t *RepoPullComment) MarshalCBOR(w io.Writer) error {
6691 if t == nil {
6692 _, err := w.Write(cbg.CborNull)
6693 return err
6694 }
6695
6696 cw := cbg.NewCborWriter(w)
6697 fieldCount := 7
6698
6699 if t.CommentId == nil {
6700 fieldCount--
6701 }
6702
6703 if t.Owner == nil {
6704 fieldCount--
6705 }
6706
6707 if t.Repo == nil {
6708 fieldCount--
6709 }
6710
6711 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6712 return err
6713 }
6714
6715 // t.Body (string) (string)
6716 if len("body") > 1000000 {
6717 return xerrors.Errorf("Value in field \"body\" was too long")
6718 }
6719
6720 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
6721 return err
6722 }
6723 if _, err := cw.WriteString(string("body")); err != nil {
6724 return err
6725 }
6726
6727 if len(t.Body) > 1000000 {
6728 return xerrors.Errorf("Value in field t.Body was too long")
6729 }
6730
6731 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
6732 return err
6733 }
6734 if _, err := cw.WriteString(string(t.Body)); err != nil {
6735 return err
6736 }
6737
6738 // t.Pull (string) (string)
6739 if len("pull") > 1000000 {
6740 return xerrors.Errorf("Value in field \"pull\" was too long")
6741 }
6742
6743 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
6744 return err
6745 }
6746 if _, err := cw.WriteString(string("pull")); err != nil {
6747 return err
6748 }
6749
6750 if len(t.Pull) > 1000000 {
6751 return xerrors.Errorf("Value in field t.Pull was too long")
6752 }
6753
6754 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
6755 return err
6756 }
6757 if _, err := cw.WriteString(string(t.Pull)); err != nil {
6758 return err
6759 }
6760
6761 // t.Repo (string) (string)
6762 if t.Repo != nil {
6763
6764 if len("repo") > 1000000 {
6765 return xerrors.Errorf("Value in field \"repo\" was too long")
6766 }
6767
6768 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6769 return err
6770 }
6771 if _, err := cw.WriteString(string("repo")); err != nil {
6772 return err
6773 }
6774
6775 if t.Repo == nil {
6776 if _, err := cw.Write(cbg.CborNull); err != nil {
6777 return err
6778 }
6779 } else {
6780 if len(*t.Repo) > 1000000 {
6781 return xerrors.Errorf("Value in field t.Repo was too long")
6782 }
6783
6784 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
6785 return err
6786 }
6787 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
6788 return err
6789 }
6790 }
6791 }
6792
6793 // t.LexiconTypeID (string) (string)
6794 if len("$type") > 1000000 {
6795 return xerrors.Errorf("Value in field \"$type\" was too long")
6796 }
6797
6798 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6799 return err
6800 }
6801 if _, err := cw.WriteString(string("$type")); err != nil {
6802 return err
6803 }
6804
6805 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.comment"))); err != nil {
6806 return err
6807 }
6808 if _, err := cw.WriteString(string("sh.tangled.repo.pull.comment")); err != nil {
6809 return err
6810 }
6811
6812 // t.Owner (string) (string)
6813 if t.Owner != nil {
6814
6815 if len("owner") > 1000000 {
6816 return xerrors.Errorf("Value in field \"owner\" was too long")
6817 }
6818
6819 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
6820 return err
6821 }
6822 if _, err := cw.WriteString(string("owner")); err != nil {
6823 return err
6824 }
6825
6826 if t.Owner == nil {
6827 if _, err := cw.Write(cbg.CborNull); err != nil {
6828 return err
6829 }
6830 } else {
6831 if len(*t.Owner) > 1000000 {
6832 return xerrors.Errorf("Value in field t.Owner was too long")
6833 }
6834
6835 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Owner))); err != nil {
6836 return err
6837 }
6838 if _, err := cw.WriteString(string(*t.Owner)); err != nil {
6839 return err
6840 }
6841 }
6842 }
6843
6844 // t.CommentId (int64) (int64)
6845 if t.CommentId != nil {
6846
6847 if len("commentId") > 1000000 {
6848 return xerrors.Errorf("Value in field \"commentId\" was too long")
6849 }
6850
6851 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commentId"))); err != nil {
6852 return err
6853 }
6854 if _, err := cw.WriteString(string("commentId")); err != nil {
6855 return err
6856 }
6857
6858 if t.CommentId == nil {
6859 if _, err := cw.Write(cbg.CborNull); err != nil {
6860 return err
6861 }
6862 } else {
6863 if *t.CommentId >= 0 {
6864 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.CommentId)); err != nil {
6865 return err
6866 }
6867 } else {
6868 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.CommentId-1)); err != nil {
6869 return err
6870 }
6871 }
6872 }
6873
6874 }
6875
6876 // t.CreatedAt (string) (string)
6877 if len("createdAt") > 1000000 {
6878 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6879 }
6880
6881 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6882 return err
6883 }
6884 if _, err := cw.WriteString(string("createdAt")); err != nil {
6885 return err
6886 }
6887
6888 if len(t.CreatedAt) > 1000000 {
6889 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6890 }
6891
6892 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6893 return err
6894 }
6895 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6896 return err
6897 }
6898 return nil
6899}
6900
6901func (t *RepoPullComment) UnmarshalCBOR(r io.Reader) (err error) {
6902 *t = RepoPullComment{}
6903
6904 cr := cbg.NewCborReader(r)
6905
6906 maj, extra, err := cr.ReadHeader()
6907 if err != nil {
6908 return err
6909 }
6910 defer func() {
6911 if err == io.EOF {
6912 err = io.ErrUnexpectedEOF
6913 }
6914 }()
6915
6916 if maj != cbg.MajMap {
6917 return fmt.Errorf("cbor input should be of type map")
6918 }
6919
6920 if extra > cbg.MaxLength {
6921 return fmt.Errorf("RepoPullComment: map struct too large (%d)", extra)
6922 }
6923
6924 n := extra
6925
6926 nameBuf := make([]byte, 9)
6927 for i := uint64(0); i < n; i++ {
6928 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6929 if err != nil {
6930 return err
6931 }
6932
6933 if !ok {
6934 // Field doesn't exist on this type, so ignore it
6935 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6936 return err
6937 }
6938 continue
6939 }
6940
6941 switch string(nameBuf[:nameLen]) {
6942 // t.Body (string) (string)
6943 case "body":
6944
6945 {
6946 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6947 if err != nil {
6948 return err
6949 }
6950
6951 t.Body = string(sval)
6952 }
6953 // t.Pull (string) (string)
6954 case "pull":
6955
6956 {
6957 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6958 if err != nil {
6959 return err
6960 }
6961
6962 t.Pull = string(sval)
6963 }
6964 // t.Repo (string) (string)
6965 case "repo":
6966
6967 {
6968 b, err := cr.ReadByte()
6969 if err != nil {
6970 return err
6971 }
6972 if b != cbg.CborNull[0] {
6973 if err := cr.UnreadByte(); err != nil {
6974 return err
6975 }
6976
6977 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6978 if err != nil {
6979 return err
6980 }
6981
6982 t.Repo = (*string)(&sval)
6983 }
6984 }
6985 // t.LexiconTypeID (string) (string)
6986 case "$type":
6987
6988 {
6989 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6990 if err != nil {
6991 return err
6992 }
6993
6994 t.LexiconTypeID = string(sval)
6995 }
6996 // t.Owner (string) (string)
6997 case "owner":
6998
6999 {
7000 b, err := cr.ReadByte()
7001 if err != nil {
7002 return err
7003 }
7004 if b != cbg.CborNull[0] {
7005 if err := cr.UnreadByte(); err != nil {
7006 return err
7007 }
7008
7009 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7010 if err != nil {
7011 return err
7012 }
7013
7014 t.Owner = (*string)(&sval)
7015 }
7016 }
7017 // t.CommentId (int64) (int64)
7018 case "commentId":
7019 {
7020
7021 b, err := cr.ReadByte()
7022 if err != nil {
7023 return err
7024 }
7025 if b != cbg.CborNull[0] {
7026 if err := cr.UnreadByte(); err != nil {
7027 return err
7028 }
7029 maj, extra, err := cr.ReadHeader()
7030 if err != nil {
7031 return err
7032 }
7033 var extraI int64
7034 switch maj {
7035 case cbg.MajUnsignedInt:
7036 extraI = int64(extra)
7037 if extraI < 0 {
7038 return fmt.Errorf("int64 positive overflow")
7039 }
7040 case cbg.MajNegativeInt:
7041 extraI = int64(extra)
7042 if extraI < 0 {
7043 return fmt.Errorf("int64 negative overflow")
7044 }
7045 extraI = -1 - extraI
7046 default:
7047 return fmt.Errorf("wrong type for int64 field: %d", maj)
7048 }
7049
7050 t.CommentId = (*int64)(&extraI)
7051 }
7052 }
7053 // t.CreatedAt (string) (string)
7054 case "createdAt":
7055
7056 {
7057 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7058 if err != nil {
7059 return err
7060 }
7061
7062 t.CreatedAt = string(sval)
7063 }
7064
7065 default:
7066 // Field doesn't exist on this type, so ignore it
7067 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7068 return err
7069 }
7070 }
7071 }
7072
7073 return nil
7074}
7075func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error {
7076 if t == nil {
7077 _, err := w.Write(cbg.CborNull)
7078 return err
7079 }
7080
7081 cw := cbg.NewCborWriter(w)
7082 fieldCount := 3
7083
7084 if t.Repo == nil {
7085 fieldCount--
7086 }
7087
7088 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7089 return err
7090 }
7091
7092 // t.Sha (string) (string)
7093 if len("sha") > 1000000 {
7094 return xerrors.Errorf("Value in field \"sha\" was too long")
7095 }
7096
7097 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sha"))); err != nil {
7098 return err
7099 }
7100 if _, err := cw.WriteString(string("sha")); err != nil {
7101 return err
7102 }
7103
7104 if len(t.Sha) > 1000000 {
7105 return xerrors.Errorf("Value in field t.Sha was too long")
7106 }
7107
7108 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Sha))); err != nil {
7109 return err
7110 }
7111 if _, err := cw.WriteString(string(t.Sha)); err != nil {
7112 return err
7113 }
7114
7115 // t.Repo (string) (string)
7116 if t.Repo != nil {
7117
7118 if len("repo") > 1000000 {
7119 return xerrors.Errorf("Value in field \"repo\" was too long")
7120 }
7121
7122 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
7123 return err
7124 }
7125 if _, err := cw.WriteString(string("repo")); err != nil {
7126 return err
7127 }
7128
7129 if t.Repo == nil {
7130 if _, err := cw.Write(cbg.CborNull); err != nil {
7131 return err
7132 }
7133 } else {
7134 if len(*t.Repo) > 1000000 {
7135 return xerrors.Errorf("Value in field t.Repo was too long")
7136 }
7137
7138 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
7139 return err
7140 }
7141 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
7142 return err
7143 }
7144 }
7145 }
7146
7147 // t.Branch (string) (string)
7148 if len("branch") > 1000000 {
7149 return xerrors.Errorf("Value in field \"branch\" was too long")
7150 }
7151
7152 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
7153 return err
7154 }
7155 if _, err := cw.WriteString(string("branch")); err != nil {
7156 return err
7157 }
7158
7159 if len(t.Branch) > 1000000 {
7160 return xerrors.Errorf("Value in field t.Branch was too long")
7161 }
7162
7163 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
7164 return err
7165 }
7166 if _, err := cw.WriteString(string(t.Branch)); err != nil {
7167 return err
7168 }
7169 return nil
7170}
7171
7172func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) {
7173 *t = RepoPull_Source{}
7174
7175 cr := cbg.NewCborReader(r)
7176
7177 maj, extra, err := cr.ReadHeader()
7178 if err != nil {
7179 return err
7180 }
7181 defer func() {
7182 if err == io.EOF {
7183 err = io.ErrUnexpectedEOF
7184 }
7185 }()
7186
7187 if maj != cbg.MajMap {
7188 return fmt.Errorf("cbor input should be of type map")
7189 }
7190
7191 if extra > cbg.MaxLength {
7192 return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra)
7193 }
7194
7195 n := extra
7196
7197 nameBuf := make([]byte, 6)
7198 for i := uint64(0); i < n; i++ {
7199 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7200 if err != nil {
7201 return err
7202 }
7203
7204 if !ok {
7205 // Field doesn't exist on this type, so ignore it
7206 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7207 return err
7208 }
7209 continue
7210 }
7211
7212 switch string(nameBuf[:nameLen]) {
7213 // t.Sha (string) (string)
7214 case "sha":
7215
7216 {
7217 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7218 if err != nil {
7219 return err
7220 }
7221
7222 t.Sha = string(sval)
7223 }
7224 // t.Repo (string) (string)
7225 case "repo":
7226
7227 {
7228 b, err := cr.ReadByte()
7229 if err != nil {
7230 return err
7231 }
7232 if b != cbg.CborNull[0] {
7233 if err := cr.UnreadByte(); err != nil {
7234 return err
7235 }
7236
7237 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7238 if err != nil {
7239 return err
7240 }
7241
7242 t.Repo = (*string)(&sval)
7243 }
7244 }
7245 // t.Branch (string) (string)
7246 case "branch":
7247
7248 {
7249 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7250 if err != nil {
7251 return err
7252 }
7253
7254 t.Branch = string(sval)
7255 }
7256
7257 default:
7258 // Field doesn't exist on this type, so ignore it
7259 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7260 return err
7261 }
7262 }
7263 }
7264
7265 return nil
7266}
7267func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error {
7268 if t == nil {
7269 _, err := w.Write(cbg.CborNull)
7270 return err
7271 }
7272
7273 cw := cbg.NewCborWriter(w)
7274
7275 if _, err := cw.Write([]byte{163}); err != nil {
7276 return err
7277 }
7278
7279 // t.Pull (string) (string)
7280 if len("pull") > 1000000 {
7281 return xerrors.Errorf("Value in field \"pull\" was too long")
7282 }
7283
7284 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
7285 return err
7286 }
7287 if _, err := cw.WriteString(string("pull")); err != nil {
7288 return err
7289 }
7290
7291 if len(t.Pull) > 1000000 {
7292 return xerrors.Errorf("Value in field t.Pull was too long")
7293 }
7294
7295 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
7296 return err
7297 }
7298 if _, err := cw.WriteString(string(t.Pull)); err != nil {
7299 return err
7300 }
7301
7302 // t.LexiconTypeID (string) (string)
7303 if len("$type") > 1000000 {
7304 return xerrors.Errorf("Value in field \"$type\" was too long")
7305 }
7306
7307 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7308 return err
7309 }
7310 if _, err := cw.WriteString(string("$type")); err != nil {
7311 return err
7312 }
7313
7314 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil {
7315 return err
7316 }
7317 if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil {
7318 return err
7319 }
7320
7321 // t.Status (string) (string)
7322 if len("status") > 1000000 {
7323 return xerrors.Errorf("Value in field \"status\" was too long")
7324 }
7325
7326 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
7327 return err
7328 }
7329 if _, err := cw.WriteString(string("status")); err != nil {
7330 return err
7331 }
7332
7333 if len(t.Status) > 1000000 {
7334 return xerrors.Errorf("Value in field t.Status was too long")
7335 }
7336
7337 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
7338 return err
7339 }
7340 if _, err := cw.WriteString(string(t.Status)); err != nil {
7341 return err
7342 }
7343 return nil
7344}
7345
7346func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) {
7347 *t = RepoPullStatus{}
7348
7349 cr := cbg.NewCborReader(r)
7350
7351 maj, extra, err := cr.ReadHeader()
7352 if err != nil {
7353 return err
7354 }
7355 defer func() {
7356 if err == io.EOF {
7357 err = io.ErrUnexpectedEOF
7358 }
7359 }()
7360
7361 if maj != cbg.MajMap {
7362 return fmt.Errorf("cbor input should be of type map")
7363 }
7364
7365 if extra > cbg.MaxLength {
7366 return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra)
7367 }
7368
7369 n := extra
7370
7371 nameBuf := make([]byte, 6)
7372 for i := uint64(0); i < n; i++ {
7373 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7374 if err != nil {
7375 return err
7376 }
7377
7378 if !ok {
7379 // Field doesn't exist on this type, so ignore it
7380 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7381 return err
7382 }
7383 continue
7384 }
7385
7386 switch string(nameBuf[:nameLen]) {
7387 // t.Pull (string) (string)
7388 case "pull":
7389
7390 {
7391 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7392 if err != nil {
7393 return err
7394 }
7395
7396 t.Pull = string(sval)
7397 }
7398 // t.LexiconTypeID (string) (string)
7399 case "$type":
7400
7401 {
7402 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7403 if err != nil {
7404 return err
7405 }
7406
7407 t.LexiconTypeID = string(sval)
7408 }
7409 // t.Status (string) (string)
7410 case "status":
7411
7412 {
7413 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7414 if err != nil {
7415 return err
7416 }
7417
7418 t.Status = string(sval)
7419 }
7420
7421 default:
7422 // Field doesn't exist on this type, so ignore it
7423 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7424 return err
7425 }
7426 }
7427 }
7428
7429 return nil
7430}
7431func (t *Spindle) MarshalCBOR(w io.Writer) error {
7432 if t == nil {
7433 _, err := w.Write(cbg.CborNull)
7434 return err
7435 }
7436
7437 cw := cbg.NewCborWriter(w)
7438
7439 if _, err := cw.Write([]byte{162}); err != nil {
7440 return err
7441 }
7442
7443 // t.LexiconTypeID (string) (string)
7444 if len("$type") > 1000000 {
7445 return xerrors.Errorf("Value in field \"$type\" was too long")
7446 }
7447
7448 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7449 return err
7450 }
7451 if _, err := cw.WriteString(string("$type")); err != nil {
7452 return err
7453 }
7454
7455 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle"))); err != nil {
7456 return err
7457 }
7458 if _, err := cw.WriteString(string("sh.tangled.spindle")); err != nil {
7459 return err
7460 }
7461
7462 // t.CreatedAt (string) (string)
7463 if len("createdAt") > 1000000 {
7464 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7465 }
7466
7467 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7468 return err
7469 }
7470 if _, err := cw.WriteString(string("createdAt")); err != nil {
7471 return err
7472 }
7473
7474 if len(t.CreatedAt) > 1000000 {
7475 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7476 }
7477
7478 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7479 return err
7480 }
7481 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7482 return err
7483 }
7484 return nil
7485}
7486
7487func (t *Spindle) UnmarshalCBOR(r io.Reader) (err error) {
7488 *t = Spindle{}
7489
7490 cr := cbg.NewCborReader(r)
7491
7492 maj, extra, err := cr.ReadHeader()
7493 if err != nil {
7494 return err
7495 }
7496 defer func() {
7497 if err == io.EOF {
7498 err = io.ErrUnexpectedEOF
7499 }
7500 }()
7501
7502 if maj != cbg.MajMap {
7503 return fmt.Errorf("cbor input should be of type map")
7504 }
7505
7506 if extra > cbg.MaxLength {
7507 return fmt.Errorf("Spindle: map struct too large (%d)", extra)
7508 }
7509
7510 n := extra
7511
7512 nameBuf := make([]byte, 9)
7513 for i := uint64(0); i < n; i++ {
7514 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7515 if err != nil {
7516 return err
7517 }
7518
7519 if !ok {
7520 // Field doesn't exist on this type, so ignore it
7521 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7522 return err
7523 }
7524 continue
7525 }
7526
7527 switch string(nameBuf[:nameLen]) {
7528 // t.LexiconTypeID (string) (string)
7529 case "$type":
7530
7531 {
7532 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7533 if err != nil {
7534 return err
7535 }
7536
7537 t.LexiconTypeID = string(sval)
7538 }
7539 // t.CreatedAt (string) (string)
7540 case "createdAt":
7541
7542 {
7543 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7544 if err != nil {
7545 return err
7546 }
7547
7548 t.CreatedAt = string(sval)
7549 }
7550
7551 default:
7552 // Field doesn't exist on this type, so ignore it
7553 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7554 return err
7555 }
7556 }
7557 }
7558
7559 return nil
7560}
7561func (t *SpindleMember) MarshalCBOR(w io.Writer) error {
7562 if t == nil {
7563 _, err := w.Write(cbg.CborNull)
7564 return err
7565 }
7566
7567 cw := cbg.NewCborWriter(w)
7568
7569 if _, err := cw.Write([]byte{164}); err != nil {
7570 return err
7571 }
7572
7573 // t.LexiconTypeID (string) (string)
7574 if len("$type") > 1000000 {
7575 return xerrors.Errorf("Value in field \"$type\" was too long")
7576 }
7577
7578 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7579 return err
7580 }
7581 if _, err := cw.WriteString(string("$type")); err != nil {
7582 return err
7583 }
7584
7585 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle.member"))); err != nil {
7586 return err
7587 }
7588 if _, err := cw.WriteString(string("sh.tangled.spindle.member")); err != nil {
7589 return err
7590 }
7591
7592 // t.Subject (string) (string)
7593 if len("subject") > 1000000 {
7594 return xerrors.Errorf("Value in field \"subject\" was too long")
7595 }
7596
7597 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
7598 return err
7599 }
7600 if _, err := cw.WriteString(string("subject")); err != nil {
7601 return err
7602 }
7603
7604 if len(t.Subject) > 1000000 {
7605 return xerrors.Errorf("Value in field t.Subject was too long")
7606 }
7607
7608 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
7609 return err
7610 }
7611 if _, err := cw.WriteString(string(t.Subject)); err != nil {
7612 return err
7613 }
7614
7615 // t.Instance (string) (string)
7616 if len("instance") > 1000000 {
7617 return xerrors.Errorf("Value in field \"instance\" was too long")
7618 }
7619
7620 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("instance"))); err != nil {
7621 return err
7622 }
7623 if _, err := cw.WriteString(string("instance")); err != nil {
7624 return err
7625 }
7626
7627 if len(t.Instance) > 1000000 {
7628 return xerrors.Errorf("Value in field t.Instance was too long")
7629 }
7630
7631 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Instance))); err != nil {
7632 return err
7633 }
7634 if _, err := cw.WriteString(string(t.Instance)); err != nil {
7635 return err
7636 }
7637
7638 // t.CreatedAt (string) (string)
7639 if len("createdAt") > 1000000 {
7640 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7641 }
7642
7643 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7644 return err
7645 }
7646 if _, err := cw.WriteString(string("createdAt")); err != nil {
7647 return err
7648 }
7649
7650 if len(t.CreatedAt) > 1000000 {
7651 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7652 }
7653
7654 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7655 return err
7656 }
7657 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7658 return err
7659 }
7660 return nil
7661}
7662
7663func (t *SpindleMember) UnmarshalCBOR(r io.Reader) (err error) {
7664 *t = SpindleMember{}
7665
7666 cr := cbg.NewCborReader(r)
7667
7668 maj, extra, err := cr.ReadHeader()
7669 if err != nil {
7670 return err
7671 }
7672 defer func() {
7673 if err == io.EOF {
7674 err = io.ErrUnexpectedEOF
7675 }
7676 }()
7677
7678 if maj != cbg.MajMap {
7679 return fmt.Errorf("cbor input should be of type map")
7680 }
7681
7682 if extra > cbg.MaxLength {
7683 return fmt.Errorf("SpindleMember: map struct too large (%d)", extra)
7684 }
7685
7686 n := extra
7687
7688 nameBuf := make([]byte, 9)
7689 for i := uint64(0); i < n; i++ {
7690 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7691 if err != nil {
7692 return err
7693 }
7694
7695 if !ok {
7696 // Field doesn't exist on this type, so ignore it
7697 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7698 return err
7699 }
7700 continue
7701 }
7702
7703 switch string(nameBuf[:nameLen]) {
7704 // t.LexiconTypeID (string) (string)
7705 case "$type":
7706
7707 {
7708 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7709 if err != nil {
7710 return err
7711 }
7712
7713 t.LexiconTypeID = string(sval)
7714 }
7715 // t.Subject (string) (string)
7716 case "subject":
7717
7718 {
7719 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7720 if err != nil {
7721 return err
7722 }
7723
7724 t.Subject = string(sval)
7725 }
7726 // t.Instance (string) (string)
7727 case "instance":
7728
7729 {
7730 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7731 if err != nil {
7732 return err
7733 }
7734
7735 t.Instance = string(sval)
7736 }
7737 // t.CreatedAt (string) (string)
7738 case "createdAt":
7739
7740 {
7741 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7742 if err != nil {
7743 return err
7744 }
7745
7746 t.CreatedAt = string(sval)
7747 }
7748
7749 default:
7750 // Field doesn't exist on this type, so ignore it
7751 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7752 return err
7753 }
7754 }
7755 }
7756
7757 return nil
7758}
7759func (t *String) MarshalCBOR(w io.Writer) error {
7760 if t == nil {
7761 _, err := w.Write(cbg.CborNull)
7762 return err
7763 }
7764
7765 cw := cbg.NewCborWriter(w)
7766
7767 if _, err := cw.Write([]byte{165}); err != nil {
7768 return err
7769 }
7770
7771 // t.LexiconTypeID (string) (string)
7772 if len("$type") > 1000000 {
7773 return xerrors.Errorf("Value in field \"$type\" was too long")
7774 }
7775
7776 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7777 return err
7778 }
7779 if _, err := cw.WriteString(string("$type")); err != nil {
7780 return err
7781 }
7782
7783 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.string"))); err != nil {
7784 return err
7785 }
7786 if _, err := cw.WriteString(string("sh.tangled.string")); err != nil {
7787 return err
7788 }
7789
7790 // t.Contents (string) (string)
7791 if len("contents") > 1000000 {
7792 return xerrors.Errorf("Value in field \"contents\" was too long")
7793 }
7794
7795 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("contents"))); err != nil {
7796 return err
7797 }
7798 if _, err := cw.WriteString(string("contents")); err != nil {
7799 return err
7800 }
7801
7802 if len(t.Contents) > 1000000 {
7803 return xerrors.Errorf("Value in field t.Contents was too long")
7804 }
7805
7806 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Contents))); err != nil {
7807 return err
7808 }
7809 if _, err := cw.WriteString(string(t.Contents)); err != nil {
7810 return err
7811 }
7812
7813 // t.Filename (string) (string)
7814 if len("filename") > 1000000 {
7815 return xerrors.Errorf("Value in field \"filename\" was too long")
7816 }
7817
7818 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("filename"))); err != nil {
7819 return err
7820 }
7821 if _, err := cw.WriteString(string("filename")); err != nil {
7822 return err
7823 }
7824
7825 if len(t.Filename) > 1000000 {
7826 return xerrors.Errorf("Value in field t.Filename was too long")
7827 }
7828
7829 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Filename))); err != nil {
7830 return err
7831 }
7832 if _, err := cw.WriteString(string(t.Filename)); err != nil {
7833 return err
7834 }
7835
7836 // t.CreatedAt (string) (string)
7837 if len("createdAt") > 1000000 {
7838 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7839 }
7840
7841 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7842 return err
7843 }
7844 if _, err := cw.WriteString(string("createdAt")); err != nil {
7845 return err
7846 }
7847
7848 if len(t.CreatedAt) > 1000000 {
7849 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7850 }
7851
7852 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7853 return err
7854 }
7855 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7856 return err
7857 }
7858
7859 // t.Description (string) (string)
7860 if len("description") > 1000000 {
7861 return xerrors.Errorf("Value in field \"description\" was too long")
7862 }
7863
7864 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
7865 return err
7866 }
7867 if _, err := cw.WriteString(string("description")); err != nil {
7868 return err
7869 }
7870
7871 if len(t.Description) > 1000000 {
7872 return xerrors.Errorf("Value in field t.Description was too long")
7873 }
7874
7875 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil {
7876 return err
7877 }
7878 if _, err := cw.WriteString(string(t.Description)); err != nil {
7879 return err
7880 }
7881 return nil
7882}
7883
7884func (t *String) UnmarshalCBOR(r io.Reader) (err error) {
7885 *t = String{}
7886
7887 cr := cbg.NewCborReader(r)
7888
7889 maj, extra, err := cr.ReadHeader()
7890 if err != nil {
7891 return err
7892 }
7893 defer func() {
7894 if err == io.EOF {
7895 err = io.ErrUnexpectedEOF
7896 }
7897 }()
7898
7899 if maj != cbg.MajMap {
7900 return fmt.Errorf("cbor input should be of type map")
7901 }
7902
7903 if extra > cbg.MaxLength {
7904 return fmt.Errorf("String: map struct too large (%d)", extra)
7905 }
7906
7907 n := extra
7908
7909 nameBuf := make([]byte, 11)
7910 for i := uint64(0); i < n; i++ {
7911 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7912 if err != nil {
7913 return err
7914 }
7915
7916 if !ok {
7917 // Field doesn't exist on this type, so ignore it
7918 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7919 return err
7920 }
7921 continue
7922 }
7923
7924 switch string(nameBuf[:nameLen]) {
7925 // t.LexiconTypeID (string) (string)
7926 case "$type":
7927
7928 {
7929 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7930 if err != nil {
7931 return err
7932 }
7933
7934 t.LexiconTypeID = string(sval)
7935 }
7936 // t.Contents (string) (string)
7937 case "contents":
7938
7939 {
7940 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7941 if err != nil {
7942 return err
7943 }
7944
7945 t.Contents = string(sval)
7946 }
7947 // t.Filename (string) (string)
7948 case "filename":
7949
7950 {
7951 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7952 if err != nil {
7953 return err
7954 }
7955
7956 t.Filename = string(sval)
7957 }
7958 // t.CreatedAt (string) (string)
7959 case "createdAt":
7960
7961 {
7962 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7963 if err != nil {
7964 return err
7965 }
7966
7967 t.CreatedAt = string(sval)
7968 }
7969 // t.Description (string) (string)
7970 case "description":
7971
7972 {
7973 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7974 if err != nil {
7975 return err
7976 }
7977
7978 t.Description = string(sval)
7979 }
7980
7981 default:
7982 // Field doesn't exist on this type, so ignore it
7983 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7984 return err
7985 }
7986 }
7987 }
7988
7989 return nil
7990}