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