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