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