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