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