sanin.dev
forked from
tangled.org/core
fork
Configure Feed
Select the types of activity you want to include in your feed.
this repo has no description
fork
Configure Feed
Select the types of activity you want to include in your feed.
anirudh.fi
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}