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