kot.pink
1// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
2
3package tangled
4
5import (
6 "fmt"
7 "io"
8 "math"
9 "sort"
10
11 util "github.com/bluesky-social/indigo/lex/util"
12 cid "github.com/ipfs/go-cid"
13 cbg "github.com/whyrusleeping/cbor-gen"
14 xerrors "golang.org/x/xerrors"
15)
16
17var _ = xerrors.Errorf
18var _ = cid.Undef
19var _ = math.E
20var _ = sort.Sort
21
22func (t *ActorProfile) MarshalCBOR(w io.Writer) error {
23 if t == nil {
24 _, err := w.Write(cbg.CborNull)
25 return err
26 }
27
28 cw := cbg.NewCborWriter(w)
29 fieldCount := 7
30
31 if t.Description == nil {
32 fieldCount--
33 }
34
35 if t.Links == nil {
36 fieldCount--
37 }
38
39 if t.Location == nil {
40 fieldCount--
41 }
42
43 if t.PinnedRepositories == nil {
44 fieldCount--
45 }
46
47 if t.Stats == nil {
48 fieldCount--
49 }
50
51 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
52 return err
53 }
54
55 // t.LexiconTypeID (string) (string)
56 if len("$type") > 1000000 {
57 return xerrors.Errorf("Value in field \"$type\" was too long")
58 }
59
60 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
61 return err
62 }
63 if _, err := cw.WriteString(string("$type")); err != nil {
64 return err
65 }
66
67 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.actor.profile"))); err != nil {
68 return err
69 }
70 if _, err := cw.WriteString(string("sh.tangled.actor.profile")); err != nil {
71 return err
72 }
73
74 // t.Links ([]string) (slice)
75 if t.Links != nil {
76
77 if len("links") > 1000000 {
78 return xerrors.Errorf("Value in field \"links\" was too long")
79 }
80
81 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("links"))); err != nil {
82 return err
83 }
84 if _, err := cw.WriteString(string("links")); err != nil {
85 return err
86 }
87
88 if len(t.Links) > 8192 {
89 return xerrors.Errorf("Slice value in field t.Links was too long")
90 }
91
92 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Links))); err != nil {
93 return err
94 }
95 for _, v := range t.Links {
96 if len(v) > 1000000 {
97 return xerrors.Errorf("Value in field v was too long")
98 }
99
100 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
101 return err
102 }
103 if _, err := cw.WriteString(string(v)); err != nil {
104 return err
105 }
106
107 }
108 }
109
110 // t.Stats ([]string) (slice)
111 if t.Stats != nil {
112
113 if len("stats") > 1000000 {
114 return xerrors.Errorf("Value in field \"stats\" was too long")
115 }
116
117 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("stats"))); err != nil {
118 return err
119 }
120 if _, err := cw.WriteString(string("stats")); err != nil {
121 return err
122 }
123
124 if len(t.Stats) > 8192 {
125 return xerrors.Errorf("Slice value in field t.Stats was too long")
126 }
127
128 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Stats))); err != nil {
129 return err
130 }
131 for _, v := range t.Stats {
132 if len(v) > 1000000 {
133 return xerrors.Errorf("Value in field v was too long")
134 }
135
136 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
137 return err
138 }
139 if _, err := cw.WriteString(string(v)); err != nil {
140 return err
141 }
142
143 }
144 }
145
146 // t.Bluesky (bool) (bool)
147 if len("bluesky") > 1000000 {
148 return xerrors.Errorf("Value in field \"bluesky\" was too long")
149 }
150
151 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("bluesky"))); err != nil {
152 return err
153 }
154 if _, err := cw.WriteString(string("bluesky")); err != nil {
155 return err
156 }
157
158 if err := cbg.WriteBool(w, t.Bluesky); err != nil {
159 return err
160 }
161
162 // t.Location (string) (string)
163 if t.Location != nil {
164
165 if len("location") > 1000000 {
166 return xerrors.Errorf("Value in field \"location\" was too long")
167 }
168
169 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("location"))); err != nil {
170 return err
171 }
172 if _, err := cw.WriteString(string("location")); err != nil {
173 return err
174 }
175
176 if t.Location == nil {
177 if _, err := cw.Write(cbg.CborNull); err != nil {
178 return err
179 }
180 } else {
181 if len(*t.Location) > 1000000 {
182 return xerrors.Errorf("Value in field t.Location was too long")
183 }
184
185 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Location))); err != nil {
186 return err
187 }
188 if _, err := cw.WriteString(string(*t.Location)); err != nil {
189 return err
190 }
191 }
192 }
193
194 // t.Description (string) (string)
195 if t.Description != nil {
196
197 if len("description") > 1000000 {
198 return xerrors.Errorf("Value in field \"description\" was too long")
199 }
200
201 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
202 return err
203 }
204 if _, err := cw.WriteString(string("description")); err != nil {
205 return err
206 }
207
208 if t.Description == nil {
209 if _, err := cw.Write(cbg.CborNull); err != nil {
210 return err
211 }
212 } else {
213 if len(*t.Description) > 1000000 {
214 return xerrors.Errorf("Value in field t.Description was too long")
215 }
216
217 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
218 return err
219 }
220 if _, err := cw.WriteString(string(*t.Description)); err != nil {
221 return err
222 }
223 }
224 }
225
226 // t.PinnedRepositories ([]string) (slice)
227 if t.PinnedRepositories != nil {
228
229 if len("pinnedRepositories") > 1000000 {
230 return xerrors.Errorf("Value in field \"pinnedRepositories\" was too long")
231 }
232
233 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pinnedRepositories"))); err != nil {
234 return err
235 }
236 if _, err := cw.WriteString(string("pinnedRepositories")); err != nil {
237 return err
238 }
239
240 if len(t.PinnedRepositories) > 8192 {
241 return xerrors.Errorf("Slice value in field t.PinnedRepositories was too long")
242 }
243
244 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.PinnedRepositories))); err != nil {
245 return err
246 }
247 for _, v := range t.PinnedRepositories {
248 if len(v) > 1000000 {
249 return xerrors.Errorf("Value in field v was too long")
250 }
251
252 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
253 return err
254 }
255 if _, err := cw.WriteString(string(v)); err != nil {
256 return err
257 }
258
259 }
260 }
261 return nil
262}
263
264func (t *ActorProfile) UnmarshalCBOR(r io.Reader) (err error) {
265 *t = ActorProfile{}
266
267 cr := cbg.NewCborReader(r)
268
269 maj, extra, err := cr.ReadHeader()
270 if err != nil {
271 return err
272 }
273 defer func() {
274 if err == io.EOF {
275 err = io.ErrUnexpectedEOF
276 }
277 }()
278
279 if maj != cbg.MajMap {
280 return fmt.Errorf("cbor input should be of type map")
281 }
282
283 if extra > cbg.MaxLength {
284 return fmt.Errorf("ActorProfile: map struct too large (%d)", extra)
285 }
286
287 n := extra
288
289 nameBuf := make([]byte, 18)
290 for i := uint64(0); i < n; i++ {
291 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
292 if err != nil {
293 return err
294 }
295
296 if !ok {
297 // Field doesn't exist on this type, so ignore it
298 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
299 return err
300 }
301 continue
302 }
303
304 switch string(nameBuf[:nameLen]) {
305 // t.LexiconTypeID (string) (string)
306 case "$type":
307
308 {
309 sval, err := cbg.ReadStringWithMax(cr, 1000000)
310 if err != nil {
311 return err
312 }
313
314 t.LexiconTypeID = string(sval)
315 }
316 // t.Links ([]string) (slice)
317 case "links":
318
319 maj, extra, err = cr.ReadHeader()
320 if err != nil {
321 return err
322 }
323
324 if extra > 8192 {
325 return fmt.Errorf("t.Links: array too large (%d)", extra)
326 }
327
328 if maj != cbg.MajArray {
329 return fmt.Errorf("expected cbor array")
330 }
331
332 if extra > 0 {
333 t.Links = make([]string, extra)
334 }
335
336 for i := 0; i < int(extra); i++ {
337 {
338 var maj byte
339 var extra uint64
340 var err error
341 _ = maj
342 _ = extra
343 _ = err
344
345 {
346 sval, err := cbg.ReadStringWithMax(cr, 1000000)
347 if err != nil {
348 return err
349 }
350
351 t.Links[i] = string(sval)
352 }
353
354 }
355 }
356 // t.Stats ([]string) (slice)
357 case "stats":
358
359 maj, extra, err = cr.ReadHeader()
360 if err != nil {
361 return err
362 }
363
364 if extra > 8192 {
365 return fmt.Errorf("t.Stats: array too large (%d)", extra)
366 }
367
368 if maj != cbg.MajArray {
369 return fmt.Errorf("expected cbor array")
370 }
371
372 if extra > 0 {
373 t.Stats = make([]string, extra)
374 }
375
376 for i := 0; i < int(extra); i++ {
377 {
378 var maj byte
379 var extra uint64
380 var err error
381 _ = maj
382 _ = extra
383 _ = err
384
385 {
386 sval, err := cbg.ReadStringWithMax(cr, 1000000)
387 if err != nil {
388 return err
389 }
390
391 t.Stats[i] = string(sval)
392 }
393
394 }
395 }
396 // t.Bluesky (bool) (bool)
397 case "bluesky":
398
399 maj, extra, err = cr.ReadHeader()
400 if err != nil {
401 return err
402 }
403 if maj != cbg.MajOther {
404 return fmt.Errorf("booleans must be major type 7")
405 }
406 switch extra {
407 case 20:
408 t.Bluesky = false
409 case 21:
410 t.Bluesky = true
411 default:
412 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
413 }
414 // t.Location (string) (string)
415 case "location":
416
417 {
418 b, err := cr.ReadByte()
419 if err != nil {
420 return err
421 }
422 if b != cbg.CborNull[0] {
423 if err := cr.UnreadByte(); err != nil {
424 return err
425 }
426
427 sval, err := cbg.ReadStringWithMax(cr, 1000000)
428 if err != nil {
429 return err
430 }
431
432 t.Location = (*string)(&sval)
433 }
434 }
435 // t.Description (string) (string)
436 case "description":
437
438 {
439 b, err := cr.ReadByte()
440 if err != nil {
441 return err
442 }
443 if b != cbg.CborNull[0] {
444 if err := cr.UnreadByte(); err != nil {
445 return err
446 }
447
448 sval, err := cbg.ReadStringWithMax(cr, 1000000)
449 if err != nil {
450 return err
451 }
452
453 t.Description = (*string)(&sval)
454 }
455 }
456 // t.PinnedRepositories ([]string) (slice)
457 case "pinnedRepositories":
458
459 maj, extra, err = cr.ReadHeader()
460 if err != nil {
461 return err
462 }
463
464 if extra > 8192 {
465 return fmt.Errorf("t.PinnedRepositories: array too large (%d)", extra)
466 }
467
468 if maj != cbg.MajArray {
469 return fmt.Errorf("expected cbor array")
470 }
471
472 if extra > 0 {
473 t.PinnedRepositories = make([]string, extra)
474 }
475
476 for i := 0; i < int(extra); i++ {
477 {
478 var maj byte
479 var extra uint64
480 var err error
481 _ = maj
482 _ = extra
483 _ = err
484
485 {
486 sval, err := cbg.ReadStringWithMax(cr, 1000000)
487 if err != nil {
488 return err
489 }
490
491 t.PinnedRepositories[i] = string(sval)
492 }
493
494 }
495 }
496
497 default:
498 // Field doesn't exist on this type, so ignore it
499 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
500 return err
501 }
502 }
503 }
504
505 return nil
506}
507func (t *FeedStar) MarshalCBOR(w io.Writer) error {
508 if t == nil {
509 _, err := w.Write(cbg.CborNull)
510 return err
511 }
512
513 cw := cbg.NewCborWriter(w)
514
515 if _, err := cw.Write([]byte{163}); err != nil {
516 return err
517 }
518
519 // t.LexiconTypeID (string) (string)
520 if len("$type") > 1000000 {
521 return xerrors.Errorf("Value in field \"$type\" was too long")
522 }
523
524 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
525 return err
526 }
527 if _, err := cw.WriteString(string("$type")); err != nil {
528 return err
529 }
530
531 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.star"))); err != nil {
532 return err
533 }
534 if _, err := cw.WriteString(string("sh.tangled.feed.star")); err != nil {
535 return err
536 }
537
538 // t.Subject (string) (string)
539 if len("subject") > 1000000 {
540 return xerrors.Errorf("Value in field \"subject\" was too long")
541 }
542
543 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
544 return err
545 }
546 if _, err := cw.WriteString(string("subject")); err != nil {
547 return err
548 }
549
550 if len(t.Subject) > 1000000 {
551 return xerrors.Errorf("Value in field t.Subject was too long")
552 }
553
554 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
555 return err
556 }
557 if _, err := cw.WriteString(string(t.Subject)); err != nil {
558 return err
559 }
560
561 // t.CreatedAt (string) (string)
562 if len("createdAt") > 1000000 {
563 return xerrors.Errorf("Value in field \"createdAt\" was too long")
564 }
565
566 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
567 return err
568 }
569 if _, err := cw.WriteString(string("createdAt")); err != nil {
570 return err
571 }
572
573 if len(t.CreatedAt) > 1000000 {
574 return xerrors.Errorf("Value in field t.CreatedAt was too long")
575 }
576
577 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
578 return err
579 }
580 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
581 return err
582 }
583 return nil
584}
585
586func (t *FeedStar) UnmarshalCBOR(r io.Reader) (err error) {
587 *t = FeedStar{}
588
589 cr := cbg.NewCborReader(r)
590
591 maj, extra, err := cr.ReadHeader()
592 if err != nil {
593 return err
594 }
595 defer func() {
596 if err == io.EOF {
597 err = io.ErrUnexpectedEOF
598 }
599 }()
600
601 if maj != cbg.MajMap {
602 return fmt.Errorf("cbor input should be of type map")
603 }
604
605 if extra > cbg.MaxLength {
606 return fmt.Errorf("FeedStar: map struct too large (%d)", extra)
607 }
608
609 n := extra
610
611 nameBuf := make([]byte, 9)
612 for i := uint64(0); i < n; i++ {
613 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
614 if err != nil {
615 return err
616 }
617
618 if !ok {
619 // Field doesn't exist on this type, so ignore it
620 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
621 return err
622 }
623 continue
624 }
625
626 switch string(nameBuf[:nameLen]) {
627 // t.LexiconTypeID (string) (string)
628 case "$type":
629
630 {
631 sval, err := cbg.ReadStringWithMax(cr, 1000000)
632 if err != nil {
633 return err
634 }
635
636 t.LexiconTypeID = string(sval)
637 }
638 // t.Subject (string) (string)
639 case "subject":
640
641 {
642 sval, err := cbg.ReadStringWithMax(cr, 1000000)
643 if err != nil {
644 return err
645 }
646
647 t.Subject = string(sval)
648 }
649 // t.CreatedAt (string) (string)
650 case "createdAt":
651
652 {
653 sval, err := cbg.ReadStringWithMax(cr, 1000000)
654 if err != nil {
655 return err
656 }
657
658 t.CreatedAt = string(sval)
659 }
660
661 default:
662 // Field doesn't exist on this type, so ignore it
663 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
664 return err
665 }
666 }
667 }
668
669 return nil
670}
671func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) MarshalCBOR(w io.Writer) error {
672 if t == nil {
673 _, err := w.Write(cbg.CborNull)
674 return err
675 }
676
677 cw := cbg.NewCborWriter(w)
678
679 if _, err := cw.Write([]byte{162}); err != nil {
680 return err
681 }
682
683 // t.Count (int64) (int64)
684 if len("count") > 1000000 {
685 return xerrors.Errorf("Value in field \"count\" was too long")
686 }
687
688 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("count"))); err != nil {
689 return err
690 }
691 if _, err := cw.WriteString(string("count")); err != nil {
692 return err
693 }
694
695 if t.Count >= 0 {
696 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Count)); err != nil {
697 return err
698 }
699 } else {
700 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Count-1)); err != nil {
701 return err
702 }
703 }
704
705 // t.Email (string) (string)
706 if len("email") > 1000000 {
707 return xerrors.Errorf("Value in field \"email\" was too long")
708 }
709
710 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("email"))); err != nil {
711 return err
712 }
713 if _, err := cw.WriteString(string("email")); err != nil {
714 return err
715 }
716
717 if len(t.Email) > 1000000 {
718 return xerrors.Errorf("Value in field t.Email was too long")
719 }
720
721 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Email))); err != nil {
722 return err
723 }
724 if _, err := cw.WriteString(string(t.Email)); err != nil {
725 return err
726 }
727 return nil
728}
729
730func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) UnmarshalCBOR(r io.Reader) (err error) {
731 *t = GitRefUpdate_Meta_CommitCount_ByEmail_Elem{}
732
733 cr := cbg.NewCborReader(r)
734
735 maj, extra, err := cr.ReadHeader()
736 if err != nil {
737 return err
738 }
739 defer func() {
740 if err == io.EOF {
741 err = io.ErrUnexpectedEOF
742 }
743 }()
744
745 if maj != cbg.MajMap {
746 return fmt.Errorf("cbor input should be of type map")
747 }
748
749 if extra > cbg.MaxLength {
750 return fmt.Errorf("GitRefUpdate_Meta_CommitCount_ByEmail_Elem: map struct too large (%d)", extra)
751 }
752
753 n := extra
754
755 nameBuf := make([]byte, 5)
756 for i := uint64(0); i < n; i++ {
757 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
758 if err != nil {
759 return err
760 }
761
762 if !ok {
763 // Field doesn't exist on this type, so ignore it
764 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
765 return err
766 }
767 continue
768 }
769
770 switch string(nameBuf[:nameLen]) {
771 // t.Count (int64) (int64)
772 case "count":
773 {
774 maj, extra, err := cr.ReadHeader()
775 if err != nil {
776 return err
777 }
778 var extraI int64
779 switch maj {
780 case cbg.MajUnsignedInt:
781 extraI = int64(extra)
782 if extraI < 0 {
783 return fmt.Errorf("int64 positive overflow")
784 }
785 case cbg.MajNegativeInt:
786 extraI = int64(extra)
787 if extraI < 0 {
788 return fmt.Errorf("int64 negative overflow")
789 }
790 extraI = -1 - extraI
791 default:
792 return fmt.Errorf("wrong type for int64 field: %d", maj)
793 }
794
795 t.Count = int64(extraI)
796 }
797 // t.Email (string) (string)
798 case "email":
799
800 {
801 sval, err := cbg.ReadStringWithMax(cr, 1000000)
802 if err != nil {
803 return err
804 }
805
806 t.Email = string(sval)
807 }
808
809 default:
810 // Field doesn't exist on this type, so ignore it
811 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
812 return err
813 }
814 }
815 }
816
817 return nil
818}
819func (t *GitRefUpdate_Meta_CommitCount) MarshalCBOR(w io.Writer) error {
820 if t == nil {
821 _, err := w.Write(cbg.CborNull)
822 return err
823 }
824
825 cw := cbg.NewCborWriter(w)
826 fieldCount := 1
827
828 if t.ByEmail == nil {
829 fieldCount--
830 }
831
832 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
833 return err
834 }
835
836 // t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice)
837 if t.ByEmail != nil {
838
839 if len("byEmail") > 1000000 {
840 return xerrors.Errorf("Value in field \"byEmail\" was too long")
841 }
842
843 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byEmail"))); err != nil {
844 return err
845 }
846 if _, err := cw.WriteString(string("byEmail")); err != nil {
847 return err
848 }
849
850 if len(t.ByEmail) > 8192 {
851 return xerrors.Errorf("Slice value in field t.ByEmail was too long")
852 }
853
854 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ByEmail))); err != nil {
855 return err
856 }
857 for _, v := range t.ByEmail {
858 if err := v.MarshalCBOR(cw); err != nil {
859 return err
860 }
861
862 }
863 }
864 return nil
865}
866
867func (t *GitRefUpdate_Meta_CommitCount) UnmarshalCBOR(r io.Reader) (err error) {
868 *t = GitRefUpdate_Meta_CommitCount{}
869
870 cr := cbg.NewCborReader(r)
871
872 maj, extra, err := cr.ReadHeader()
873 if err != nil {
874 return err
875 }
876 defer func() {
877 if err == io.EOF {
878 err = io.ErrUnexpectedEOF
879 }
880 }()
881
882 if maj != cbg.MajMap {
883 return fmt.Errorf("cbor input should be of type map")
884 }
885
886 if extra > cbg.MaxLength {
887 return fmt.Errorf("GitRefUpdate_Meta_CommitCount: map struct too large (%d)", extra)
888 }
889
890 n := extra
891
892 nameBuf := make([]byte, 7)
893 for i := uint64(0); i < n; i++ {
894 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
895 if err != nil {
896 return err
897 }
898
899 if !ok {
900 // Field doesn't exist on this type, so ignore it
901 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
902 return err
903 }
904 continue
905 }
906
907 switch string(nameBuf[:nameLen]) {
908 // t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice)
909 case "byEmail":
910
911 maj, extra, err = cr.ReadHeader()
912 if err != nil {
913 return err
914 }
915
916 if extra > 8192 {
917 return fmt.Errorf("t.ByEmail: array too large (%d)", extra)
918 }
919
920 if maj != cbg.MajArray {
921 return fmt.Errorf("expected cbor array")
922 }
923
924 if extra > 0 {
925 t.ByEmail = make([]*GitRefUpdate_Meta_CommitCount_ByEmail_Elem, extra)
926 }
927
928 for i := 0; i < int(extra); i++ {
929 {
930 var maj byte
931 var extra uint64
932 var err error
933 _ = maj
934 _ = extra
935 _ = err
936
937 {
938
939 b, err := cr.ReadByte()
940 if err != nil {
941 return err
942 }
943 if b != cbg.CborNull[0] {
944 if err := cr.UnreadByte(); err != nil {
945 return err
946 }
947 t.ByEmail[i] = new(GitRefUpdate_Meta_CommitCount_ByEmail_Elem)
948 if err := t.ByEmail[i].UnmarshalCBOR(cr); err != nil {
949 return xerrors.Errorf("unmarshaling t.ByEmail[i] pointer: %w", err)
950 }
951 }
952
953 }
954
955 }
956 }
957
958 default:
959 // Field doesn't exist on this type, so ignore it
960 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
961 return err
962 }
963 }
964 }
965
966 return nil
967}
968func (t *GitRefUpdate_Meta) MarshalCBOR(w io.Writer) error {
969 if t == nil {
970 _, err := w.Write(cbg.CborNull)
971 return err
972 }
973
974 cw := cbg.NewCborWriter(w)
975
976 if _, err := cw.Write([]byte{162}); err != nil {
977 return err
978 }
979
980 // t.CommitCount (tangled.GitRefUpdate_Meta_CommitCount) (struct)
981 if len("commitCount") > 1000000 {
982 return xerrors.Errorf("Value in field \"commitCount\" was too long")
983 }
984
985 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commitCount"))); err != nil {
986 return err
987 }
988 if _, err := cw.WriteString(string("commitCount")); err != nil {
989 return err
990 }
991
992 if err := t.CommitCount.MarshalCBOR(cw); err != nil {
993 return err
994 }
995
996 // t.IsDefaultRef (bool) (bool)
997 if len("isDefaultRef") > 1000000 {
998 return xerrors.Errorf("Value in field \"isDefaultRef\" was too long")
999 }
1000
1001 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("isDefaultRef"))); err != nil {
1002 return err
1003 }
1004 if _, err := cw.WriteString(string("isDefaultRef")); err != nil {
1005 return err
1006 }
1007
1008 if err := cbg.WriteBool(w, t.IsDefaultRef); err != nil {
1009 return err
1010 }
1011 return nil
1012}
1013
1014func (t *GitRefUpdate_Meta) UnmarshalCBOR(r io.Reader) (err error) {
1015 *t = GitRefUpdate_Meta{}
1016
1017 cr := cbg.NewCborReader(r)
1018
1019 maj, extra, err := cr.ReadHeader()
1020 if err != nil {
1021 return err
1022 }
1023 defer func() {
1024 if err == io.EOF {
1025 err = io.ErrUnexpectedEOF
1026 }
1027 }()
1028
1029 if maj != cbg.MajMap {
1030 return fmt.Errorf("cbor input should be of type map")
1031 }
1032
1033 if extra > cbg.MaxLength {
1034 return fmt.Errorf("GitRefUpdate_Meta: map struct too large (%d)", extra)
1035 }
1036
1037 n := extra
1038
1039 nameBuf := make([]byte, 12)
1040 for i := uint64(0); i < n; i++ {
1041 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1042 if err != nil {
1043 return err
1044 }
1045
1046 if !ok {
1047 // Field doesn't exist on this type, so ignore it
1048 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1049 return err
1050 }
1051 continue
1052 }
1053
1054 switch string(nameBuf[:nameLen]) {
1055 // t.CommitCount (tangled.GitRefUpdate_Meta_CommitCount) (struct)
1056 case "commitCount":
1057
1058 {
1059
1060 b, err := cr.ReadByte()
1061 if err != nil {
1062 return err
1063 }
1064 if b != cbg.CborNull[0] {
1065 if err := cr.UnreadByte(); err != nil {
1066 return err
1067 }
1068 t.CommitCount = new(GitRefUpdate_Meta_CommitCount)
1069 if err := t.CommitCount.UnmarshalCBOR(cr); err != nil {
1070 return xerrors.Errorf("unmarshaling t.CommitCount pointer: %w", err)
1071 }
1072 }
1073
1074 }
1075 // t.IsDefaultRef (bool) (bool)
1076 case "isDefaultRef":
1077
1078 maj, extra, err = cr.ReadHeader()
1079 if err != nil {
1080 return err
1081 }
1082 if maj != cbg.MajOther {
1083 return fmt.Errorf("booleans must be major type 7")
1084 }
1085 switch extra {
1086 case 20:
1087 t.IsDefaultRef = false
1088 case 21:
1089 t.IsDefaultRef = true
1090 default:
1091 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
1092 }
1093
1094 default:
1095 // Field doesn't exist on this type, so ignore it
1096 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1097 return err
1098 }
1099 }
1100 }
1101
1102 return nil
1103}
1104func (t *GitRefUpdate) MarshalCBOR(w io.Writer) error {
1105 if t == nil {
1106 _, err := w.Write(cbg.CborNull)
1107 return err
1108 }
1109
1110 cw := cbg.NewCborWriter(w)
1111
1112 if _, err := cw.Write([]byte{168}); err != nil {
1113 return err
1114 }
1115
1116 // t.Ref (string) (string)
1117 if len("ref") > 1000000 {
1118 return xerrors.Errorf("Value in field \"ref\" was too long")
1119 }
1120
1121 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
1122 return err
1123 }
1124 if _, err := cw.WriteString(string("ref")); err != nil {
1125 return err
1126 }
1127
1128 if len(t.Ref) > 1000000 {
1129 return xerrors.Errorf("Value in field t.Ref was too long")
1130 }
1131
1132 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
1133 return err
1134 }
1135 if _, err := cw.WriteString(string(t.Ref)); err != nil {
1136 return err
1137 }
1138
1139 // t.Meta (tangled.GitRefUpdate_Meta) (struct)
1140 if len("meta") > 1000000 {
1141 return xerrors.Errorf("Value in field \"meta\" was too long")
1142 }
1143
1144 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil {
1145 return err
1146 }
1147 if _, err := cw.WriteString(string("meta")); err != nil {
1148 return err
1149 }
1150
1151 if err := t.Meta.MarshalCBOR(cw); err != nil {
1152 return err
1153 }
1154
1155 // t.LexiconTypeID (string) (string)
1156 if len("$type") > 1000000 {
1157 return xerrors.Errorf("Value in field \"$type\" was too long")
1158 }
1159
1160 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
1161 return err
1162 }
1163 if _, err := cw.WriteString(string("$type")); err != nil {
1164 return err
1165 }
1166
1167 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.git.refUpdate"))); err != nil {
1168 return err
1169 }
1170 if _, err := cw.WriteString(string("sh.tangled.git.refUpdate")); err != nil {
1171 return err
1172 }
1173
1174 // t.NewSha (string) (string)
1175 if len("newSha") > 1000000 {
1176 return xerrors.Errorf("Value in field \"newSha\" was too long")
1177 }
1178
1179 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
1180 return err
1181 }
1182 if _, err := cw.WriteString(string("newSha")); err != nil {
1183 return err
1184 }
1185
1186 if len(t.NewSha) > 1000000 {
1187 return xerrors.Errorf("Value in field t.NewSha was too long")
1188 }
1189
1190 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
1191 return err
1192 }
1193 if _, err := cw.WriteString(string(t.NewSha)); err != nil {
1194 return err
1195 }
1196
1197 // t.OldSha (string) (string)
1198 if len("oldSha") > 1000000 {
1199 return xerrors.Errorf("Value in field \"oldSha\" was too long")
1200 }
1201
1202 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
1203 return err
1204 }
1205 if _, err := cw.WriteString(string("oldSha")); err != nil {
1206 return err
1207 }
1208
1209 if len(t.OldSha) > 1000000 {
1210 return xerrors.Errorf("Value in field t.OldSha was too long")
1211 }
1212
1213 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
1214 return err
1215 }
1216 if _, err := cw.WriteString(string(t.OldSha)); err != nil {
1217 return err
1218 }
1219
1220 // t.RepoDid (string) (string)
1221 if len("repoDid") > 1000000 {
1222 return xerrors.Errorf("Value in field \"repoDid\" was too long")
1223 }
1224
1225 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
1226 return err
1227 }
1228 if _, err := cw.WriteString(string("repoDid")); err != nil {
1229 return err
1230 }
1231
1232 if len(t.RepoDid) > 1000000 {
1233 return xerrors.Errorf("Value in field t.RepoDid was too long")
1234 }
1235
1236 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoDid))); err != nil {
1237 return err
1238 }
1239 if _, err := cw.WriteString(string(t.RepoDid)); err != nil {
1240 return err
1241 }
1242
1243 // t.RepoName (string) (string)
1244 if len("repoName") > 1000000 {
1245 return xerrors.Errorf("Value in field \"repoName\" was too long")
1246 }
1247
1248 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoName"))); err != nil {
1249 return err
1250 }
1251 if _, err := cw.WriteString(string("repoName")); err != nil {
1252 return err
1253 }
1254
1255 if len(t.RepoName) > 1000000 {
1256 return xerrors.Errorf("Value in field t.RepoName was too long")
1257 }
1258
1259 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoName))); err != nil {
1260 return err
1261 }
1262 if _, err := cw.WriteString(string(t.RepoName)); err != nil {
1263 return err
1264 }
1265
1266 // t.CommitterDid (string) (string)
1267 if len("committerDid") > 1000000 {
1268 return xerrors.Errorf("Value in field \"committerDid\" was too long")
1269 }
1270
1271 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("committerDid"))); err != nil {
1272 return err
1273 }
1274 if _, err := cw.WriteString(string("committerDid")); err != nil {
1275 return err
1276 }
1277
1278 if len(t.CommitterDid) > 1000000 {
1279 return xerrors.Errorf("Value in field t.CommitterDid was too long")
1280 }
1281
1282 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CommitterDid))); err != nil {
1283 return err
1284 }
1285 if _, err := cw.WriteString(string(t.CommitterDid)); err != nil {
1286 return err
1287 }
1288 return nil
1289}
1290
1291func (t *GitRefUpdate) UnmarshalCBOR(r io.Reader) (err error) {
1292 *t = GitRefUpdate{}
1293
1294 cr := cbg.NewCborReader(r)
1295
1296 maj, extra, err := cr.ReadHeader()
1297 if err != nil {
1298 return err
1299 }
1300 defer func() {
1301 if err == io.EOF {
1302 err = io.ErrUnexpectedEOF
1303 }
1304 }()
1305
1306 if maj != cbg.MajMap {
1307 return fmt.Errorf("cbor input should be of type map")
1308 }
1309
1310 if extra > cbg.MaxLength {
1311 return fmt.Errorf("GitRefUpdate: map struct too large (%d)", extra)
1312 }
1313
1314 n := extra
1315
1316 nameBuf := make([]byte, 12)
1317 for i := uint64(0); i < n; i++ {
1318 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1319 if err != nil {
1320 return err
1321 }
1322
1323 if !ok {
1324 // Field doesn't exist on this type, so ignore it
1325 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1326 return err
1327 }
1328 continue
1329 }
1330
1331 switch string(nameBuf[:nameLen]) {
1332 // t.Ref (string) (string)
1333 case "ref":
1334
1335 {
1336 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1337 if err != nil {
1338 return err
1339 }
1340
1341 t.Ref = string(sval)
1342 }
1343 // t.Meta (tangled.GitRefUpdate_Meta) (struct)
1344 case "meta":
1345
1346 {
1347
1348 b, err := cr.ReadByte()
1349 if err != nil {
1350 return err
1351 }
1352 if b != cbg.CborNull[0] {
1353 if err := cr.UnreadByte(); err != nil {
1354 return err
1355 }
1356 t.Meta = new(GitRefUpdate_Meta)
1357 if err := t.Meta.UnmarshalCBOR(cr); err != nil {
1358 return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err)
1359 }
1360 }
1361
1362 }
1363 // t.LexiconTypeID (string) (string)
1364 case "$type":
1365
1366 {
1367 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1368 if err != nil {
1369 return err
1370 }
1371
1372 t.LexiconTypeID = string(sval)
1373 }
1374 // t.NewSha (string) (string)
1375 case "newSha":
1376
1377 {
1378 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1379 if err != nil {
1380 return err
1381 }
1382
1383 t.NewSha = string(sval)
1384 }
1385 // t.OldSha (string) (string)
1386 case "oldSha":
1387
1388 {
1389 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1390 if err != nil {
1391 return err
1392 }
1393
1394 t.OldSha = string(sval)
1395 }
1396 // t.RepoDid (string) (string)
1397 case "repoDid":
1398
1399 {
1400 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1401 if err != nil {
1402 return err
1403 }
1404
1405 t.RepoDid = string(sval)
1406 }
1407 // t.RepoName (string) (string)
1408 case "repoName":
1409
1410 {
1411 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1412 if err != nil {
1413 return err
1414 }
1415
1416 t.RepoName = string(sval)
1417 }
1418 // t.CommitterDid (string) (string)
1419 case "committerDid":
1420
1421 {
1422 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1423 if err != nil {
1424 return err
1425 }
1426
1427 t.CommitterDid = string(sval)
1428 }
1429
1430 default:
1431 // Field doesn't exist on this type, so ignore it
1432 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1433 return err
1434 }
1435 }
1436 }
1437
1438 return nil
1439}
1440func (t *GraphFollow) MarshalCBOR(w io.Writer) error {
1441 if t == nil {
1442 _, err := w.Write(cbg.CborNull)
1443 return err
1444 }
1445
1446 cw := cbg.NewCborWriter(w)
1447
1448 if _, err := cw.Write([]byte{163}); err != nil {
1449 return err
1450 }
1451
1452 // t.LexiconTypeID (string) (string)
1453 if len("$type") > 1000000 {
1454 return xerrors.Errorf("Value in field \"$type\" was too long")
1455 }
1456
1457 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
1458 return err
1459 }
1460 if _, err := cw.WriteString(string("$type")); err != nil {
1461 return err
1462 }
1463
1464 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.graph.follow"))); err != nil {
1465 return err
1466 }
1467 if _, err := cw.WriteString(string("sh.tangled.graph.follow")); err != nil {
1468 return err
1469 }
1470
1471 // t.Subject (string) (string)
1472 if len("subject") > 1000000 {
1473 return xerrors.Errorf("Value in field \"subject\" was too long")
1474 }
1475
1476 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
1477 return err
1478 }
1479 if _, err := cw.WriteString(string("subject")); err != nil {
1480 return err
1481 }
1482
1483 if len(t.Subject) > 1000000 {
1484 return xerrors.Errorf("Value in field t.Subject was too long")
1485 }
1486
1487 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
1488 return err
1489 }
1490 if _, err := cw.WriteString(string(t.Subject)); err != nil {
1491 return err
1492 }
1493
1494 // t.CreatedAt (string) (string)
1495 if len("createdAt") > 1000000 {
1496 return xerrors.Errorf("Value in field \"createdAt\" was too long")
1497 }
1498
1499 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
1500 return err
1501 }
1502 if _, err := cw.WriteString(string("createdAt")); err != nil {
1503 return err
1504 }
1505
1506 if len(t.CreatedAt) > 1000000 {
1507 return xerrors.Errorf("Value in field t.CreatedAt was too long")
1508 }
1509
1510 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
1511 return err
1512 }
1513 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
1514 return err
1515 }
1516 return nil
1517}
1518
1519func (t *GraphFollow) UnmarshalCBOR(r io.Reader) (err error) {
1520 *t = GraphFollow{}
1521
1522 cr := cbg.NewCborReader(r)
1523
1524 maj, extra, err := cr.ReadHeader()
1525 if err != nil {
1526 return err
1527 }
1528 defer func() {
1529 if err == io.EOF {
1530 err = io.ErrUnexpectedEOF
1531 }
1532 }()
1533
1534 if maj != cbg.MajMap {
1535 return fmt.Errorf("cbor input should be of type map")
1536 }
1537
1538 if extra > cbg.MaxLength {
1539 return fmt.Errorf("GraphFollow: map struct too large (%d)", extra)
1540 }
1541
1542 n := extra
1543
1544 nameBuf := make([]byte, 9)
1545 for i := uint64(0); i < n; i++ {
1546 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1547 if err != nil {
1548 return err
1549 }
1550
1551 if !ok {
1552 // Field doesn't exist on this type, so ignore it
1553 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1554 return err
1555 }
1556 continue
1557 }
1558
1559 switch string(nameBuf[:nameLen]) {
1560 // t.LexiconTypeID (string) (string)
1561 case "$type":
1562
1563 {
1564 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1565 if err != nil {
1566 return err
1567 }
1568
1569 t.LexiconTypeID = string(sval)
1570 }
1571 // t.Subject (string) (string)
1572 case "subject":
1573
1574 {
1575 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1576 if err != nil {
1577 return err
1578 }
1579
1580 t.Subject = string(sval)
1581 }
1582 // t.CreatedAt (string) (string)
1583 case "createdAt":
1584
1585 {
1586 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1587 if err != nil {
1588 return err
1589 }
1590
1591 t.CreatedAt = string(sval)
1592 }
1593
1594 default:
1595 // Field doesn't exist on this type, so ignore it
1596 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1597 return err
1598 }
1599 }
1600 }
1601
1602 return nil
1603}
1604func (t *KnotMember) MarshalCBOR(w io.Writer) error {
1605 if t == nil {
1606 _, err := w.Write(cbg.CborNull)
1607 return err
1608 }
1609
1610 cw := cbg.NewCborWriter(w)
1611
1612 if _, err := cw.Write([]byte{164}); err != nil {
1613 return err
1614 }
1615
1616 // t.LexiconTypeID (string) (string)
1617 if len("$type") > 1000000 {
1618 return xerrors.Errorf("Value in field \"$type\" was too long")
1619 }
1620
1621 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
1622 return err
1623 }
1624 if _, err := cw.WriteString(string("$type")); err != nil {
1625 return err
1626 }
1627
1628 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot.member"))); err != nil {
1629 return err
1630 }
1631 if _, err := cw.WriteString(string("sh.tangled.knot.member")); err != nil {
1632 return err
1633 }
1634
1635 // t.Domain (string) (string)
1636 if len("domain") > 1000000 {
1637 return xerrors.Errorf("Value in field \"domain\" was too long")
1638 }
1639
1640 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("domain"))); err != nil {
1641 return err
1642 }
1643 if _, err := cw.WriteString(string("domain")); err != nil {
1644 return err
1645 }
1646
1647 if len(t.Domain) > 1000000 {
1648 return xerrors.Errorf("Value in field t.Domain was too long")
1649 }
1650
1651 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Domain))); err != nil {
1652 return err
1653 }
1654 if _, err := cw.WriteString(string(t.Domain)); err != nil {
1655 return err
1656 }
1657
1658 // t.Subject (string) (string)
1659 if len("subject") > 1000000 {
1660 return xerrors.Errorf("Value in field \"subject\" was too long")
1661 }
1662
1663 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
1664 return err
1665 }
1666 if _, err := cw.WriteString(string("subject")); err != nil {
1667 return err
1668 }
1669
1670 if len(t.Subject) > 1000000 {
1671 return xerrors.Errorf("Value in field t.Subject was too long")
1672 }
1673
1674 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
1675 return err
1676 }
1677 if _, err := cw.WriteString(string(t.Subject)); err != nil {
1678 return err
1679 }
1680
1681 // t.CreatedAt (string) (string)
1682 if len("createdAt") > 1000000 {
1683 return xerrors.Errorf("Value in field \"createdAt\" was too long")
1684 }
1685
1686 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
1687 return err
1688 }
1689 if _, err := cw.WriteString(string("createdAt")); err != nil {
1690 return err
1691 }
1692
1693 if len(t.CreatedAt) > 1000000 {
1694 return xerrors.Errorf("Value in field t.CreatedAt was too long")
1695 }
1696
1697 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
1698 return err
1699 }
1700 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
1701 return err
1702 }
1703 return nil
1704}
1705
1706func (t *KnotMember) UnmarshalCBOR(r io.Reader) (err error) {
1707 *t = KnotMember{}
1708
1709 cr := cbg.NewCborReader(r)
1710
1711 maj, extra, err := cr.ReadHeader()
1712 if err != nil {
1713 return err
1714 }
1715 defer func() {
1716 if err == io.EOF {
1717 err = io.ErrUnexpectedEOF
1718 }
1719 }()
1720
1721 if maj != cbg.MajMap {
1722 return fmt.Errorf("cbor input should be of type map")
1723 }
1724
1725 if extra > cbg.MaxLength {
1726 return fmt.Errorf("KnotMember: map struct too large (%d)", extra)
1727 }
1728
1729 n := extra
1730
1731 nameBuf := make([]byte, 9)
1732 for i := uint64(0); i < n; i++ {
1733 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1734 if err != nil {
1735 return err
1736 }
1737
1738 if !ok {
1739 // Field doesn't exist on this type, so ignore it
1740 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1741 return err
1742 }
1743 continue
1744 }
1745
1746 switch string(nameBuf[:nameLen]) {
1747 // t.LexiconTypeID (string) (string)
1748 case "$type":
1749
1750 {
1751 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1752 if err != nil {
1753 return err
1754 }
1755
1756 t.LexiconTypeID = string(sval)
1757 }
1758 // t.Domain (string) (string)
1759 case "domain":
1760
1761 {
1762 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1763 if err != nil {
1764 return err
1765 }
1766
1767 t.Domain = string(sval)
1768 }
1769 // t.Subject (string) (string)
1770 case "subject":
1771
1772 {
1773 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1774 if err != nil {
1775 return err
1776 }
1777
1778 t.Subject = string(sval)
1779 }
1780 // t.CreatedAt (string) (string)
1781 case "createdAt":
1782
1783 {
1784 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1785 if err != nil {
1786 return err
1787 }
1788
1789 t.CreatedAt = string(sval)
1790 }
1791
1792 default:
1793 // Field doesn't exist on this type, so ignore it
1794 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1795 return err
1796 }
1797 }
1798 }
1799
1800 return nil
1801}
1802func (t *PipelineStatus) MarshalCBOR(w io.Writer) error {
1803 if t == nil {
1804 _, err := w.Write(cbg.CborNull)
1805 return err
1806 }
1807
1808 cw := cbg.NewCborWriter(w)
1809 fieldCount := 7
1810
1811 if t.Error == nil {
1812 fieldCount--
1813 }
1814
1815 if t.ExitCode == nil {
1816 fieldCount--
1817 }
1818
1819 if _, 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_Environment_Elem) 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.Key (string) (string)
3185 if len("key") > 1000000 {
3186 return xerrors.Errorf("Value in field \"key\" was too long")
3187 }
3188
3189 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
3190 return err
3191 }
3192 if _, err := cw.WriteString(string("key")); err != nil {
3193 return err
3194 }
3195
3196 if len(t.Key) > 1000000 {
3197 return xerrors.Errorf("Value in field t.Key was too long")
3198 }
3199
3200 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
3201 return err
3202 }
3203 if _, err := cw.WriteString(string(t.Key)); err != nil {
3204 return err
3205 }
3206
3207 // t.Value (string) (string)
3208 if len("value") > 1000000 {
3209 return xerrors.Errorf("Value in field \"value\" was too long")
3210 }
3211
3212 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
3213 return err
3214 }
3215 if _, err := cw.WriteString(string("value")); err != nil {
3216 return err
3217 }
3218
3219 if len(t.Value) > 1000000 {
3220 return xerrors.Errorf("Value in field t.Value was too long")
3221 }
3222
3223 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
3224 return err
3225 }
3226 if _, err := cw.WriteString(string(t.Value)); err != nil {
3227 return err
3228 }
3229 return nil
3230}
3231
3232func (t *Pipeline_Step_Environment_Elem) UnmarshalCBOR(r io.Reader) (err error) {
3233 *t = Pipeline_Step_Environment_Elem{}
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_Environment_Elem: map struct too large (%d)", extra)
3253 }
3254
3255 n := extra
3256
3257 nameBuf := make([]byte, 5)
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.Key (string) (string)
3274 case "key":
3275
3276 {
3277 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3278 if err != nil {
3279 return err
3280 }
3281
3282 t.Key = string(sval)
3283 }
3284 // t.Value (string) (string)
3285 case "value":
3286
3287 {
3288 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3289 if err != nil {
3290 return err
3291 }
3292
3293 t.Value = 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_Step) 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 := 3
3314
3315 if t.Environment == nil {
3316 fieldCount--
3317 }
3318
3319 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3320 return err
3321 }
3322
3323 // t.Name (string) (string)
3324 if len("name") > 1000000 {
3325 return xerrors.Errorf("Value in field \"name\" was too long")
3326 }
3327
3328 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
3329 return err
3330 }
3331 if _, err := cw.WriteString(string("name")); err != nil {
3332 return err
3333 }
3334
3335 if len(t.Name) > 1000000 {
3336 return xerrors.Errorf("Value in field t.Name was too long")
3337 }
3338
3339 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
3340 return err
3341 }
3342 if _, err := cw.WriteString(string(t.Name)); err != nil {
3343 return err
3344 }
3345
3346 // t.Command (string) (string)
3347 if len("command") > 1000000 {
3348 return xerrors.Errorf("Value in field \"command\" was too long")
3349 }
3350
3351 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("command"))); err != nil {
3352 return err
3353 }
3354 if _, err := cw.WriteString(string("command")); err != nil {
3355 return err
3356 }
3357
3358 if len(t.Command) > 1000000 {
3359 return xerrors.Errorf("Value in field t.Command was too long")
3360 }
3361
3362 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Command))); err != nil {
3363 return err
3364 }
3365 if _, err := cw.WriteString(string(t.Command)); err != nil {
3366 return err
3367 }
3368
3369 // t.Environment ([]*tangled.Pipeline_Step_Environment_Elem) (slice)
3370 if t.Environment != nil {
3371
3372 if len("environment") > 1000000 {
3373 return xerrors.Errorf("Value in field \"environment\" was too long")
3374 }
3375
3376 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("environment"))); err != nil {
3377 return err
3378 }
3379 if _, err := cw.WriteString(string("environment")); err != nil {
3380 return err
3381 }
3382
3383 if len(t.Environment) > 8192 {
3384 return xerrors.Errorf("Slice value in field t.Environment was too long")
3385 }
3386
3387 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Environment))); err != nil {
3388 return err
3389 }
3390 for _, v := range t.Environment {
3391 if err := v.MarshalCBOR(cw); err != nil {
3392 return err
3393 }
3394
3395 }
3396 }
3397 return nil
3398}
3399
3400func (t *Pipeline_Step) UnmarshalCBOR(r io.Reader) (err error) {
3401 *t = Pipeline_Step{}
3402
3403 cr := cbg.NewCborReader(r)
3404
3405 maj, extra, err := cr.ReadHeader()
3406 if err != nil {
3407 return err
3408 }
3409 defer func() {
3410 if err == io.EOF {
3411 err = io.ErrUnexpectedEOF
3412 }
3413 }()
3414
3415 if maj != cbg.MajMap {
3416 return fmt.Errorf("cbor input should be of type map")
3417 }
3418
3419 if extra > cbg.MaxLength {
3420 return fmt.Errorf("Pipeline_Step: map struct too large (%d)", extra)
3421 }
3422
3423 n := extra
3424
3425 nameBuf := make([]byte, 11)
3426 for i := uint64(0); i < n; i++ {
3427 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3428 if err != nil {
3429 return err
3430 }
3431
3432 if !ok {
3433 // Field doesn't exist on this type, so ignore it
3434 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3435 return err
3436 }
3437 continue
3438 }
3439
3440 switch string(nameBuf[:nameLen]) {
3441 // t.Name (string) (string)
3442 case "name":
3443
3444 {
3445 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3446 if err != nil {
3447 return err
3448 }
3449
3450 t.Name = string(sval)
3451 }
3452 // t.Command (string) (string)
3453 case "command":
3454
3455 {
3456 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3457 if err != nil {
3458 return err
3459 }
3460
3461 t.Command = string(sval)
3462 }
3463 // t.Environment ([]*tangled.Pipeline_Step_Environment_Elem) (slice)
3464 case "environment":
3465
3466 maj, extra, err = cr.ReadHeader()
3467 if err != nil {
3468 return err
3469 }
3470
3471 if extra > 8192 {
3472 return fmt.Errorf("t.Environment: array too large (%d)", extra)
3473 }
3474
3475 if maj != cbg.MajArray {
3476 return fmt.Errorf("expected cbor array")
3477 }
3478
3479 if extra > 0 {
3480 t.Environment = make([]*Pipeline_Step_Environment_Elem, extra)
3481 }
3482
3483 for i := 0; i < int(extra); i++ {
3484 {
3485 var maj byte
3486 var extra uint64
3487 var err error
3488 _ = maj
3489 _ = extra
3490 _ = err
3491
3492 {
3493
3494 b, err := cr.ReadByte()
3495 if err != nil {
3496 return err
3497 }
3498 if b != cbg.CborNull[0] {
3499 if err := cr.UnreadByte(); err != nil {
3500 return err
3501 }
3502 t.Environment[i] = new(Pipeline_Step_Environment_Elem)
3503 if err := t.Environment[i].UnmarshalCBOR(cr); err != nil {
3504 return xerrors.Errorf("unmarshaling t.Environment[i] pointer: %w", err)
3505 }
3506 }
3507
3508 }
3509
3510 }
3511 }
3512
3513 default:
3514 // Field doesn't exist on this type, so ignore it
3515 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3516 return err
3517 }
3518 }
3519 }
3520
3521 return nil
3522}
3523func (t *Pipeline_TriggerMetadata) MarshalCBOR(w io.Writer) error {
3524 if t == nil {
3525 _, err := w.Write(cbg.CborNull)
3526 return err
3527 }
3528
3529 cw := cbg.NewCborWriter(w)
3530 fieldCount := 5
3531
3532 if t.Manual == nil {
3533 fieldCount--
3534 }
3535
3536 if t.PullRequest == nil {
3537 fieldCount--
3538 }
3539
3540 if t.Push == nil {
3541 fieldCount--
3542 }
3543
3544 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3545 return err
3546 }
3547
3548 // t.Kind (string) (string)
3549 if len("kind") > 1000000 {
3550 return xerrors.Errorf("Value in field \"kind\" was too long")
3551 }
3552
3553 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("kind"))); err != nil {
3554 return err
3555 }
3556 if _, err := cw.WriteString(string("kind")); err != nil {
3557 return err
3558 }
3559
3560 if len(t.Kind) > 1000000 {
3561 return xerrors.Errorf("Value in field t.Kind was too long")
3562 }
3563
3564 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Kind))); err != nil {
3565 return err
3566 }
3567 if _, err := cw.WriteString(string(t.Kind)); err != nil {
3568 return err
3569 }
3570
3571 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
3572 if t.Push != nil {
3573
3574 if len("push") > 1000000 {
3575 return xerrors.Errorf("Value in field \"push\" was too long")
3576 }
3577
3578 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("push"))); err != nil {
3579 return err
3580 }
3581 if _, err := cw.WriteString(string("push")); err != nil {
3582 return err
3583 }
3584
3585 if err := t.Push.MarshalCBOR(cw); err != nil {
3586 return err
3587 }
3588 }
3589
3590 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
3591 if len("repo") > 1000000 {
3592 return xerrors.Errorf("Value in field \"repo\" was too long")
3593 }
3594
3595 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
3596 return err
3597 }
3598 if _, err := cw.WriteString(string("repo")); err != nil {
3599 return err
3600 }
3601
3602 if err := t.Repo.MarshalCBOR(cw); err != nil {
3603 return err
3604 }
3605
3606 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
3607 if t.Manual != nil {
3608
3609 if len("manual") > 1000000 {
3610 return xerrors.Errorf("Value in field \"manual\" was too long")
3611 }
3612
3613 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("manual"))); err != nil {
3614 return err
3615 }
3616 if _, err := cw.WriteString(string("manual")); err != nil {
3617 return err
3618 }
3619
3620 if err := t.Manual.MarshalCBOR(cw); err != nil {
3621 return err
3622 }
3623 }
3624
3625 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
3626 if t.PullRequest != nil {
3627
3628 if len("pullRequest") > 1000000 {
3629 return xerrors.Errorf("Value in field \"pullRequest\" was too long")
3630 }
3631
3632 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullRequest"))); err != nil {
3633 return err
3634 }
3635 if _, err := cw.WriteString(string("pullRequest")); err != nil {
3636 return err
3637 }
3638
3639 if err := t.PullRequest.MarshalCBOR(cw); err != nil {
3640 return err
3641 }
3642 }
3643 return nil
3644}
3645
3646func (t *Pipeline_TriggerMetadata) UnmarshalCBOR(r io.Reader) (err error) {
3647 *t = Pipeline_TriggerMetadata{}
3648
3649 cr := cbg.NewCborReader(r)
3650
3651 maj, extra, err := cr.ReadHeader()
3652 if err != nil {
3653 return err
3654 }
3655 defer func() {
3656 if err == io.EOF {
3657 err = io.ErrUnexpectedEOF
3658 }
3659 }()
3660
3661 if maj != cbg.MajMap {
3662 return fmt.Errorf("cbor input should be of type map")
3663 }
3664
3665 if extra > cbg.MaxLength {
3666 return fmt.Errorf("Pipeline_TriggerMetadata: map struct too large (%d)", extra)
3667 }
3668
3669 n := extra
3670
3671 nameBuf := make([]byte, 11)
3672 for i := uint64(0); i < n; i++ {
3673 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3674 if err != nil {
3675 return err
3676 }
3677
3678 if !ok {
3679 // Field doesn't exist on this type, so ignore it
3680 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3681 return err
3682 }
3683 continue
3684 }
3685
3686 switch string(nameBuf[:nameLen]) {
3687 // t.Kind (string) (string)
3688 case "kind":
3689
3690 {
3691 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3692 if err != nil {
3693 return err
3694 }
3695
3696 t.Kind = string(sval)
3697 }
3698 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
3699 case "push":
3700
3701 {
3702
3703 b, err := cr.ReadByte()
3704 if err != nil {
3705 return err
3706 }
3707 if b != cbg.CborNull[0] {
3708 if err := cr.UnreadByte(); err != nil {
3709 return err
3710 }
3711 t.Push = new(Pipeline_PushTriggerData)
3712 if err := t.Push.UnmarshalCBOR(cr); err != nil {
3713 return xerrors.Errorf("unmarshaling t.Push pointer: %w", err)
3714 }
3715 }
3716
3717 }
3718 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
3719 case "repo":
3720
3721 {
3722
3723 b, err := cr.ReadByte()
3724 if err != nil {
3725 return err
3726 }
3727 if b != cbg.CborNull[0] {
3728 if err := cr.UnreadByte(); err != nil {
3729 return err
3730 }
3731 t.Repo = new(Pipeline_TriggerRepo)
3732 if err := t.Repo.UnmarshalCBOR(cr); err != nil {
3733 return xerrors.Errorf("unmarshaling t.Repo pointer: %w", err)
3734 }
3735 }
3736
3737 }
3738 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
3739 case "manual":
3740
3741 {
3742
3743 b, err := cr.ReadByte()
3744 if err != nil {
3745 return err
3746 }
3747 if b != cbg.CborNull[0] {
3748 if err := cr.UnreadByte(); err != nil {
3749 return err
3750 }
3751 t.Manual = new(Pipeline_ManualTriggerData)
3752 if err := t.Manual.UnmarshalCBOR(cr); err != nil {
3753 return xerrors.Errorf("unmarshaling t.Manual pointer: %w", err)
3754 }
3755 }
3756
3757 }
3758 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
3759 case "pullRequest":
3760
3761 {
3762
3763 b, err := cr.ReadByte()
3764 if err != nil {
3765 return err
3766 }
3767 if b != cbg.CborNull[0] {
3768 if err := cr.UnreadByte(); err != nil {
3769 return err
3770 }
3771 t.PullRequest = new(Pipeline_PullRequestTriggerData)
3772 if err := t.PullRequest.UnmarshalCBOR(cr); err != nil {
3773 return xerrors.Errorf("unmarshaling t.PullRequest pointer: %w", err)
3774 }
3775 }
3776
3777 }
3778
3779 default:
3780 // Field doesn't exist on this type, so ignore it
3781 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3782 return err
3783 }
3784 }
3785 }
3786
3787 return nil
3788}
3789func (t *Pipeline_TriggerRepo) MarshalCBOR(w io.Writer) error {
3790 if t == nil {
3791 _, err := w.Write(cbg.CborNull)
3792 return err
3793 }
3794
3795 cw := cbg.NewCborWriter(w)
3796
3797 if _, err := cw.Write([]byte{164}); err != nil {
3798 return err
3799 }
3800
3801 // t.Did (string) (string)
3802 if len("did") > 1000000 {
3803 return xerrors.Errorf("Value in field \"did\" was too long")
3804 }
3805
3806 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil {
3807 return err
3808 }
3809 if _, err := cw.WriteString(string("did")); err != nil {
3810 return err
3811 }
3812
3813 if len(t.Did) > 1000000 {
3814 return xerrors.Errorf("Value in field t.Did was too long")
3815 }
3816
3817 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil {
3818 return err
3819 }
3820 if _, err := cw.WriteString(string(t.Did)); err != nil {
3821 return err
3822 }
3823
3824 // t.Knot (string) (string)
3825 if len("knot") > 1000000 {
3826 return xerrors.Errorf("Value in field \"knot\" was too long")
3827 }
3828
3829 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
3830 return err
3831 }
3832 if _, err := cw.WriteString(string("knot")); err != nil {
3833 return err
3834 }
3835
3836 if len(t.Knot) > 1000000 {
3837 return xerrors.Errorf("Value in field t.Knot was too long")
3838 }
3839
3840 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
3841 return err
3842 }
3843 if _, err := cw.WriteString(string(t.Knot)); err != nil {
3844 return err
3845 }
3846
3847 // t.Repo (string) (string)
3848 if len("repo") > 1000000 {
3849 return xerrors.Errorf("Value in field \"repo\" was too long")
3850 }
3851
3852 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
3853 return err
3854 }
3855 if _, err := cw.WriteString(string("repo")); err != nil {
3856 return err
3857 }
3858
3859 if len(t.Repo) > 1000000 {
3860 return xerrors.Errorf("Value in field t.Repo was too long")
3861 }
3862
3863 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
3864 return err
3865 }
3866 if _, err := cw.WriteString(string(t.Repo)); err != nil {
3867 return err
3868 }
3869
3870 // t.DefaultBranch (string) (string)
3871 if len("defaultBranch") > 1000000 {
3872 return xerrors.Errorf("Value in field \"defaultBranch\" was too long")
3873 }
3874
3875 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("defaultBranch"))); err != nil {
3876 return err
3877 }
3878 if _, err := cw.WriteString(string("defaultBranch")); err != nil {
3879 return err
3880 }
3881
3882 if len(t.DefaultBranch) > 1000000 {
3883 return xerrors.Errorf("Value in field t.DefaultBranch was too long")
3884 }
3885
3886 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.DefaultBranch))); err != nil {
3887 return err
3888 }
3889 if _, err := cw.WriteString(string(t.DefaultBranch)); err != nil {
3890 return err
3891 }
3892 return nil
3893}
3894
3895func (t *Pipeline_TriggerRepo) UnmarshalCBOR(r io.Reader) (err error) {
3896 *t = Pipeline_TriggerRepo{}
3897
3898 cr := cbg.NewCborReader(r)
3899
3900 maj, extra, err := cr.ReadHeader()
3901 if err != nil {
3902 return err
3903 }
3904 defer func() {
3905 if err == io.EOF {
3906 err = io.ErrUnexpectedEOF
3907 }
3908 }()
3909
3910 if maj != cbg.MajMap {
3911 return fmt.Errorf("cbor input should be of type map")
3912 }
3913
3914 if extra > cbg.MaxLength {
3915 return fmt.Errorf("Pipeline_TriggerRepo: map struct too large (%d)", extra)
3916 }
3917
3918 n := extra
3919
3920 nameBuf := make([]byte, 13)
3921 for i := uint64(0); i < n; i++ {
3922 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3923 if err != nil {
3924 return err
3925 }
3926
3927 if !ok {
3928 // Field doesn't exist on this type, so ignore it
3929 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3930 return err
3931 }
3932 continue
3933 }
3934
3935 switch string(nameBuf[:nameLen]) {
3936 // t.Did (string) (string)
3937 case "did":
3938
3939 {
3940 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3941 if err != nil {
3942 return err
3943 }
3944
3945 t.Did = string(sval)
3946 }
3947 // t.Knot (string) (string)
3948 case "knot":
3949
3950 {
3951 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3952 if err != nil {
3953 return err
3954 }
3955
3956 t.Knot = string(sval)
3957 }
3958 // t.Repo (string) (string)
3959 case "repo":
3960
3961 {
3962 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3963 if err != nil {
3964 return err
3965 }
3966
3967 t.Repo = string(sval)
3968 }
3969 // t.DefaultBranch (string) (string)
3970 case "defaultBranch":
3971
3972 {
3973 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3974 if err != nil {
3975 return err
3976 }
3977
3978 t.DefaultBranch = string(sval)
3979 }
3980
3981 default:
3982 // Field doesn't exist on this type, so ignore it
3983 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3984 return err
3985 }
3986 }
3987 }
3988
3989 return nil
3990}
3991func (t *Pipeline_Workflow_Environment_Elem) MarshalCBOR(w io.Writer) error {
3992 if t == nil {
3993 _, err := w.Write(cbg.CborNull)
3994 return err
3995 }
3996
3997 cw := cbg.NewCborWriter(w)
3998
3999 if _, err := cw.Write([]byte{162}); err != nil {
4000 return err
4001 }
4002
4003 // t.Key (string) (string)
4004 if len("key") > 1000000 {
4005 return xerrors.Errorf("Value in field \"key\" was too long")
4006 }
4007
4008 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
4009 return err
4010 }
4011 if _, err := cw.WriteString(string("key")); err != nil {
4012 return err
4013 }
4014
4015 if len(t.Key) > 1000000 {
4016 return xerrors.Errorf("Value in field t.Key was too long")
4017 }
4018
4019 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
4020 return err
4021 }
4022 if _, err := cw.WriteString(string(t.Key)); err != nil {
4023 return err
4024 }
4025
4026 // t.Value (string) (string)
4027 if len("value") > 1000000 {
4028 return xerrors.Errorf("Value in field \"value\" was too long")
4029 }
4030
4031 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
4032 return err
4033 }
4034 if _, err := cw.WriteString(string("value")); err != nil {
4035 return err
4036 }
4037
4038 if len(t.Value) > 1000000 {
4039 return xerrors.Errorf("Value in field t.Value was too long")
4040 }
4041
4042 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
4043 return err
4044 }
4045 if _, err := cw.WriteString(string(t.Value)); err != nil {
4046 return err
4047 }
4048 return nil
4049}
4050
4051func (t *Pipeline_Workflow_Environment_Elem) UnmarshalCBOR(r io.Reader) (err error) {
4052 *t = Pipeline_Workflow_Environment_Elem{}
4053
4054 cr := cbg.NewCborReader(r)
4055
4056 maj, extra, err := cr.ReadHeader()
4057 if err != nil {
4058 return err
4059 }
4060 defer func() {
4061 if err == io.EOF {
4062 err = io.ErrUnexpectedEOF
4063 }
4064 }()
4065
4066 if maj != cbg.MajMap {
4067 return fmt.Errorf("cbor input should be of type map")
4068 }
4069
4070 if extra > cbg.MaxLength {
4071 return fmt.Errorf("Pipeline_Workflow_Environment_Elem: map struct too large (%d)", extra)
4072 }
4073
4074 n := extra
4075
4076 nameBuf := make([]byte, 5)
4077 for i := uint64(0); i < n; i++ {
4078 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4079 if err != nil {
4080 return err
4081 }
4082
4083 if !ok {
4084 // Field doesn't exist on this type, so ignore it
4085 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4086 return err
4087 }
4088 continue
4089 }
4090
4091 switch string(nameBuf[:nameLen]) {
4092 // t.Key (string) (string)
4093 case "key":
4094
4095 {
4096 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4097 if err != nil {
4098 return err
4099 }
4100
4101 t.Key = string(sval)
4102 }
4103 // t.Value (string) (string)
4104 case "value":
4105
4106 {
4107 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4108 if err != nil {
4109 return err
4110 }
4111
4112 t.Value = string(sval)
4113 }
4114
4115 default:
4116 // Field doesn't exist on this type, so ignore it
4117 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4118 return err
4119 }
4120 }
4121 }
4122
4123 return nil
4124}
4125func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error {
4126 if t == nil {
4127 _, err := w.Write(cbg.CborNull)
4128 return err
4129 }
4130
4131 cw := cbg.NewCborWriter(w)
4132
4133 if _, err := cw.Write([]byte{165}); err != nil {
4134 return err
4135 }
4136
4137 // t.Name (string) (string)
4138 if len("name") > 1000000 {
4139 return xerrors.Errorf("Value in field \"name\" was too long")
4140 }
4141
4142 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
4143 return err
4144 }
4145 if _, err := cw.WriteString(string("name")); err != nil {
4146 return err
4147 }
4148
4149 if len(t.Name) > 1000000 {
4150 return xerrors.Errorf("Value in field t.Name was too long")
4151 }
4152
4153 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
4154 return err
4155 }
4156 if _, err := cw.WriteString(string(t.Name)); err != nil {
4157 return err
4158 }
4159
4160 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
4161 if len("clone") > 1000000 {
4162 return xerrors.Errorf("Value in field \"clone\" was too long")
4163 }
4164
4165 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil {
4166 return err
4167 }
4168 if _, err := cw.WriteString(string("clone")); err != nil {
4169 return err
4170 }
4171
4172 if err := t.Clone.MarshalCBOR(cw); err != nil {
4173 return err
4174 }
4175
4176 // t.Steps ([]*tangled.Pipeline_Step) (slice)
4177 if len("steps") > 1000000 {
4178 return xerrors.Errorf("Value in field \"steps\" was too long")
4179 }
4180
4181 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("steps"))); err != nil {
4182 return err
4183 }
4184 if _, err := cw.WriteString(string("steps")); err != nil {
4185 return err
4186 }
4187
4188 if len(t.Steps) > 8192 {
4189 return xerrors.Errorf("Slice value in field t.Steps was too long")
4190 }
4191
4192 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Steps))); err != nil {
4193 return err
4194 }
4195 for _, v := range t.Steps {
4196 if err := v.MarshalCBOR(cw); err != nil {
4197 return err
4198 }
4199
4200 }
4201
4202 // t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice)
4203 if len("environment") > 1000000 {
4204 return xerrors.Errorf("Value in field \"environment\" was too long")
4205 }
4206
4207 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("environment"))); err != nil {
4208 return err
4209 }
4210 if _, err := cw.WriteString(string("environment")); err != nil {
4211 return err
4212 }
4213
4214 if len(t.Environment) > 8192 {
4215 return xerrors.Errorf("Slice value in field t.Environment was too long")
4216 }
4217
4218 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Environment))); err != nil {
4219 return err
4220 }
4221 for _, v := range t.Environment {
4222 if err := v.MarshalCBOR(cw); err != nil {
4223 return err
4224 }
4225
4226 }
4227
4228 // t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice)
4229 if len("dependencies") > 1000000 {
4230 return xerrors.Errorf("Value in field \"dependencies\" was too long")
4231 }
4232
4233 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("dependencies"))); err != nil {
4234 return err
4235 }
4236 if _, err := cw.WriteString(string("dependencies")); err != nil {
4237 return err
4238 }
4239
4240 if len(t.Dependencies) > 8192 {
4241 return xerrors.Errorf("Slice value in field t.Dependencies was too long")
4242 }
4243
4244 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Dependencies))); err != nil {
4245 return err
4246 }
4247 for _, v := range t.Dependencies {
4248 if err := v.MarshalCBOR(cw); err != nil {
4249 return err
4250 }
4251
4252 }
4253 return nil
4254}
4255
4256func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) {
4257 *t = Pipeline_Workflow{}
4258
4259 cr := cbg.NewCborReader(r)
4260
4261 maj, extra, err := cr.ReadHeader()
4262 if err != nil {
4263 return err
4264 }
4265 defer func() {
4266 if err == io.EOF {
4267 err = io.ErrUnexpectedEOF
4268 }
4269 }()
4270
4271 if maj != cbg.MajMap {
4272 return fmt.Errorf("cbor input should be of type map")
4273 }
4274
4275 if extra > cbg.MaxLength {
4276 return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra)
4277 }
4278
4279 n := extra
4280
4281 nameBuf := make([]byte, 12)
4282 for i := uint64(0); i < n; i++ {
4283 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4284 if err != nil {
4285 return err
4286 }
4287
4288 if !ok {
4289 // Field doesn't exist on this type, so ignore it
4290 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4291 return err
4292 }
4293 continue
4294 }
4295
4296 switch string(nameBuf[:nameLen]) {
4297 // t.Name (string) (string)
4298 case "name":
4299
4300 {
4301 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4302 if err != nil {
4303 return err
4304 }
4305
4306 t.Name = string(sval)
4307 }
4308 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
4309 case "clone":
4310
4311 {
4312
4313 b, err := cr.ReadByte()
4314 if err != nil {
4315 return err
4316 }
4317 if b != cbg.CborNull[0] {
4318 if err := cr.UnreadByte(); err != nil {
4319 return err
4320 }
4321 t.Clone = new(Pipeline_CloneOpts)
4322 if err := t.Clone.UnmarshalCBOR(cr); err != nil {
4323 return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err)
4324 }
4325 }
4326
4327 }
4328 // t.Steps ([]*tangled.Pipeline_Step) (slice)
4329 case "steps":
4330
4331 maj, extra, err = cr.ReadHeader()
4332 if err != nil {
4333 return err
4334 }
4335
4336 if extra > 8192 {
4337 return fmt.Errorf("t.Steps: array too large (%d)", extra)
4338 }
4339
4340 if maj != cbg.MajArray {
4341 return fmt.Errorf("expected cbor array")
4342 }
4343
4344 if extra > 0 {
4345 t.Steps = make([]*Pipeline_Step, extra)
4346 }
4347
4348 for i := 0; i < int(extra); i++ {
4349 {
4350 var maj byte
4351 var extra uint64
4352 var err error
4353 _ = maj
4354 _ = extra
4355 _ = err
4356
4357 {
4358
4359 b, err := cr.ReadByte()
4360 if err != nil {
4361 return err
4362 }
4363 if b != cbg.CborNull[0] {
4364 if err := cr.UnreadByte(); err != nil {
4365 return err
4366 }
4367 t.Steps[i] = new(Pipeline_Step)
4368 if err := t.Steps[i].UnmarshalCBOR(cr); err != nil {
4369 return xerrors.Errorf("unmarshaling t.Steps[i] pointer: %w", err)
4370 }
4371 }
4372
4373 }
4374
4375 }
4376 }
4377 // t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice)
4378 case "environment":
4379
4380 maj, extra, err = cr.ReadHeader()
4381 if err != nil {
4382 return err
4383 }
4384
4385 if extra > 8192 {
4386 return fmt.Errorf("t.Environment: array too large (%d)", extra)
4387 }
4388
4389 if maj != cbg.MajArray {
4390 return fmt.Errorf("expected cbor array")
4391 }
4392
4393 if extra > 0 {
4394 t.Environment = make([]*Pipeline_Workflow_Environment_Elem, extra)
4395 }
4396
4397 for i := 0; i < int(extra); i++ {
4398 {
4399 var maj byte
4400 var extra uint64
4401 var err error
4402 _ = maj
4403 _ = extra
4404 _ = err
4405
4406 {
4407
4408 b, err := cr.ReadByte()
4409 if err != nil {
4410 return err
4411 }
4412 if b != cbg.CborNull[0] {
4413 if err := cr.UnreadByte(); err != nil {
4414 return err
4415 }
4416 t.Environment[i] = new(Pipeline_Workflow_Environment_Elem)
4417 if err := t.Environment[i].UnmarshalCBOR(cr); err != nil {
4418 return xerrors.Errorf("unmarshaling t.Environment[i] pointer: %w", err)
4419 }
4420 }
4421
4422 }
4423
4424 }
4425 }
4426 // t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice)
4427 case "dependencies":
4428
4429 maj, extra, err = cr.ReadHeader()
4430 if err != nil {
4431 return err
4432 }
4433
4434 if extra > 8192 {
4435 return fmt.Errorf("t.Dependencies: array too large (%d)", extra)
4436 }
4437
4438 if maj != cbg.MajArray {
4439 return fmt.Errorf("expected cbor array")
4440 }
4441
4442 if extra > 0 {
4443 t.Dependencies = make([]Pipeline_Dependencies_Elem, extra)
4444 }
4445
4446 for i := 0; i < int(extra); i++ {
4447 {
4448 var maj byte
4449 var extra uint64
4450 var err error
4451 _ = maj
4452 _ = extra
4453 _ = err
4454
4455 {
4456
4457 if err := t.Dependencies[i].UnmarshalCBOR(cr); err != nil {
4458 return xerrors.Errorf("unmarshaling t.Dependencies[i]: %w", err)
4459 }
4460
4461 }
4462
4463 }
4464 }
4465
4466 default:
4467 // Field doesn't exist on this type, so ignore it
4468 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4469 return err
4470 }
4471 }
4472 }
4473
4474 return nil
4475}
4476func (t *Pipeline) MarshalCBOR(w io.Writer) error {
4477 if t == nil {
4478 _, err := w.Write(cbg.CborNull)
4479 return err
4480 }
4481
4482 cw := cbg.NewCborWriter(w)
4483
4484 if _, err := cw.Write([]byte{163}); err != nil {
4485 return err
4486 }
4487
4488 // t.LexiconTypeID (string) (string)
4489 if len("$type") > 1000000 {
4490 return xerrors.Errorf("Value in field \"$type\" was too long")
4491 }
4492
4493 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
4494 return err
4495 }
4496 if _, err := cw.WriteString(string("$type")); err != nil {
4497 return err
4498 }
4499
4500 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil {
4501 return err
4502 }
4503 if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil {
4504 return err
4505 }
4506
4507 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
4508 if len("workflows") > 1000000 {
4509 return xerrors.Errorf("Value in field \"workflows\" was too long")
4510 }
4511
4512 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil {
4513 return err
4514 }
4515 if _, err := cw.WriteString(string("workflows")); err != nil {
4516 return err
4517 }
4518
4519 if len(t.Workflows) > 8192 {
4520 return xerrors.Errorf("Slice value in field t.Workflows was too long")
4521 }
4522
4523 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil {
4524 return err
4525 }
4526 for _, v := range t.Workflows {
4527 if err := v.MarshalCBOR(cw); err != nil {
4528 return err
4529 }
4530
4531 }
4532
4533 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
4534 if len("triggerMetadata") > 1000000 {
4535 return xerrors.Errorf("Value in field \"triggerMetadata\" was too long")
4536 }
4537
4538 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil {
4539 return err
4540 }
4541 if _, err := cw.WriteString(string("triggerMetadata")); err != nil {
4542 return err
4543 }
4544
4545 if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil {
4546 return err
4547 }
4548 return nil
4549}
4550
4551func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) {
4552 *t = Pipeline{}
4553
4554 cr := cbg.NewCborReader(r)
4555
4556 maj, extra, err := cr.ReadHeader()
4557 if err != nil {
4558 return err
4559 }
4560 defer func() {
4561 if err == io.EOF {
4562 err = io.ErrUnexpectedEOF
4563 }
4564 }()
4565
4566 if maj != cbg.MajMap {
4567 return fmt.Errorf("cbor input should be of type map")
4568 }
4569
4570 if extra > cbg.MaxLength {
4571 return fmt.Errorf("Pipeline: map struct too large (%d)", extra)
4572 }
4573
4574 n := extra
4575
4576 nameBuf := make([]byte, 15)
4577 for i := uint64(0); i < n; i++ {
4578 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4579 if err != nil {
4580 return err
4581 }
4582
4583 if !ok {
4584 // Field doesn't exist on this type, so ignore it
4585 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4586 return err
4587 }
4588 continue
4589 }
4590
4591 switch string(nameBuf[:nameLen]) {
4592 // t.LexiconTypeID (string) (string)
4593 case "$type":
4594
4595 {
4596 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4597 if err != nil {
4598 return err
4599 }
4600
4601 t.LexiconTypeID = string(sval)
4602 }
4603 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
4604 case "workflows":
4605
4606 maj, extra, err = cr.ReadHeader()
4607 if err != nil {
4608 return err
4609 }
4610
4611 if extra > 8192 {
4612 return fmt.Errorf("t.Workflows: array too large (%d)", extra)
4613 }
4614
4615 if maj != cbg.MajArray {
4616 return fmt.Errorf("expected cbor array")
4617 }
4618
4619 if extra > 0 {
4620 t.Workflows = make([]*Pipeline_Workflow, extra)
4621 }
4622
4623 for i := 0; i < int(extra); i++ {
4624 {
4625 var maj byte
4626 var extra uint64
4627 var err error
4628 _ = maj
4629 _ = extra
4630 _ = err
4631
4632 {
4633
4634 b, err := cr.ReadByte()
4635 if err != nil {
4636 return err
4637 }
4638 if b != cbg.CborNull[0] {
4639 if err := cr.UnreadByte(); err != nil {
4640 return err
4641 }
4642 t.Workflows[i] = new(Pipeline_Workflow)
4643 if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil {
4644 return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err)
4645 }
4646 }
4647
4648 }
4649
4650 }
4651 }
4652 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
4653 case "triggerMetadata":
4654
4655 {
4656
4657 b, err := cr.ReadByte()
4658 if err != nil {
4659 return err
4660 }
4661 if b != cbg.CborNull[0] {
4662 if err := cr.UnreadByte(); err != nil {
4663 return err
4664 }
4665 t.TriggerMetadata = new(Pipeline_TriggerMetadata)
4666 if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil {
4667 return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err)
4668 }
4669 }
4670
4671 }
4672
4673 default:
4674 // Field doesn't exist on this type, so ignore it
4675 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4676 return err
4677 }
4678 }
4679 }
4680
4681 return nil
4682}
4683func (t *PublicKey) MarshalCBOR(w io.Writer) error {
4684 if t == nil {
4685 _, err := w.Write(cbg.CborNull)
4686 return err
4687 }
4688
4689 cw := cbg.NewCborWriter(w)
4690
4691 if _, err := cw.Write([]byte{164}); err != nil {
4692 return err
4693 }
4694
4695 // t.Key (string) (string)
4696 if len("key") > 1000000 {
4697 return xerrors.Errorf("Value in field \"key\" was too long")
4698 }
4699
4700 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
4701 return err
4702 }
4703 if _, err := cw.WriteString(string("key")); err != nil {
4704 return err
4705 }
4706
4707 if len(t.Key) > 1000000 {
4708 return xerrors.Errorf("Value in field t.Key was too long")
4709 }
4710
4711 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
4712 return err
4713 }
4714 if _, err := cw.WriteString(string(t.Key)); err != nil {
4715 return err
4716 }
4717
4718 // t.Name (string) (string)
4719 if len("name") > 1000000 {
4720 return xerrors.Errorf("Value in field \"name\" was too long")
4721 }
4722
4723 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
4724 return err
4725 }
4726 if _, err := cw.WriteString(string("name")); err != nil {
4727 return err
4728 }
4729
4730 if len(t.Name) > 1000000 {
4731 return xerrors.Errorf("Value in field t.Name was too long")
4732 }
4733
4734 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
4735 return err
4736 }
4737 if _, err := cw.WriteString(string(t.Name)); err != nil {
4738 return err
4739 }
4740
4741 // t.LexiconTypeID (string) (string)
4742 if len("$type") > 1000000 {
4743 return xerrors.Errorf("Value in field \"$type\" was too long")
4744 }
4745
4746 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
4747 return err
4748 }
4749 if _, err := cw.WriteString(string("$type")); err != nil {
4750 return err
4751 }
4752
4753 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil {
4754 return err
4755 }
4756 if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil {
4757 return err
4758 }
4759
4760 // t.CreatedAt (string) (string)
4761 if len("createdAt") > 1000000 {
4762 return xerrors.Errorf("Value in field \"createdAt\" was too long")
4763 }
4764
4765 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
4766 return err
4767 }
4768 if _, err := cw.WriteString(string("createdAt")); err != nil {
4769 return err
4770 }
4771
4772 if len(t.CreatedAt) > 1000000 {
4773 return xerrors.Errorf("Value in field t.CreatedAt was too long")
4774 }
4775
4776 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
4777 return err
4778 }
4779 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
4780 return err
4781 }
4782 return nil
4783}
4784
4785func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) {
4786 *t = PublicKey{}
4787
4788 cr := cbg.NewCborReader(r)
4789
4790 maj, extra, err := cr.ReadHeader()
4791 if err != nil {
4792 return err
4793 }
4794 defer func() {
4795 if err == io.EOF {
4796 err = io.ErrUnexpectedEOF
4797 }
4798 }()
4799
4800 if maj != cbg.MajMap {
4801 return fmt.Errorf("cbor input should be of type map")
4802 }
4803
4804 if extra > cbg.MaxLength {
4805 return fmt.Errorf("PublicKey: map struct too large (%d)", extra)
4806 }
4807
4808 n := extra
4809
4810 nameBuf := make([]byte, 9)
4811 for i := uint64(0); i < n; i++ {
4812 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4813 if err != nil {
4814 return err
4815 }
4816
4817 if !ok {
4818 // Field doesn't exist on this type, so ignore it
4819 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4820 return err
4821 }
4822 continue
4823 }
4824
4825 switch string(nameBuf[:nameLen]) {
4826 // t.Key (string) (string)
4827 case "key":
4828
4829 {
4830 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4831 if err != nil {
4832 return err
4833 }
4834
4835 t.Key = string(sval)
4836 }
4837 // t.Name (string) (string)
4838 case "name":
4839
4840 {
4841 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4842 if err != nil {
4843 return err
4844 }
4845
4846 t.Name = string(sval)
4847 }
4848 // t.LexiconTypeID (string) (string)
4849 case "$type":
4850
4851 {
4852 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4853 if err != nil {
4854 return err
4855 }
4856
4857 t.LexiconTypeID = string(sval)
4858 }
4859 // t.CreatedAt (string) (string)
4860 case "createdAt":
4861
4862 {
4863 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4864 if err != nil {
4865 return err
4866 }
4867
4868 t.CreatedAt = string(sval)
4869 }
4870
4871 default:
4872 // Field doesn't exist on this type, so ignore it
4873 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4874 return err
4875 }
4876 }
4877 }
4878
4879 return nil
4880}
4881func (t *RepoArtifact) MarshalCBOR(w io.Writer) error {
4882 if t == nil {
4883 _, err := w.Write(cbg.CborNull)
4884 return err
4885 }
4886
4887 cw := cbg.NewCborWriter(w)
4888 fieldCount := 6
4889
4890 if t.Tag == nil {
4891 fieldCount--
4892 }
4893
4894 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4895 return err
4896 }
4897
4898 // t.Tag (util.LexBytes) (slice)
4899 if t.Tag != nil {
4900
4901 if len("tag") > 1000000 {
4902 return xerrors.Errorf("Value in field \"tag\" was too long")
4903 }
4904
4905 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tag"))); err != nil {
4906 return err
4907 }
4908 if _, err := cw.WriteString(string("tag")); err != nil {
4909 return err
4910 }
4911
4912 if len(t.Tag) > 2097152 {
4913 return xerrors.Errorf("Byte array in field t.Tag was too long")
4914 }
4915
4916 if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Tag))); err != nil {
4917 return err
4918 }
4919
4920 if _, err := cw.Write(t.Tag); err != nil {
4921 return err
4922 }
4923
4924 }
4925
4926 // t.Name (string) (string)
4927 if len("name") > 1000000 {
4928 return xerrors.Errorf("Value in field \"name\" was too long")
4929 }
4930
4931 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
4932 return err
4933 }
4934 if _, err := cw.WriteString(string("name")); err != nil {
4935 return err
4936 }
4937
4938 if len(t.Name) > 1000000 {
4939 return xerrors.Errorf("Value in field t.Name was too long")
4940 }
4941
4942 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
4943 return err
4944 }
4945 if _, err := cw.WriteString(string(t.Name)); err != nil {
4946 return err
4947 }
4948
4949 // t.Repo (string) (string)
4950 if len("repo") > 1000000 {
4951 return xerrors.Errorf("Value in field \"repo\" was too long")
4952 }
4953
4954 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
4955 return err
4956 }
4957 if _, err := cw.WriteString(string("repo")); err != nil {
4958 return err
4959 }
4960
4961 if len(t.Repo) > 1000000 {
4962 return xerrors.Errorf("Value in field t.Repo was too long")
4963 }
4964
4965 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
4966 return err
4967 }
4968 if _, err := cw.WriteString(string(t.Repo)); err != nil {
4969 return err
4970 }
4971
4972 // t.LexiconTypeID (string) (string)
4973 if len("$type") > 1000000 {
4974 return xerrors.Errorf("Value in field \"$type\" was too long")
4975 }
4976
4977 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
4978 return err
4979 }
4980 if _, err := cw.WriteString(string("$type")); err != nil {
4981 return err
4982 }
4983
4984 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.artifact"))); err != nil {
4985 return err
4986 }
4987 if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil {
4988 return err
4989 }
4990
4991 // t.Artifact (util.LexBlob) (struct)
4992 if len("artifact") > 1000000 {
4993 return xerrors.Errorf("Value in field \"artifact\" was too long")
4994 }
4995
4996 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("artifact"))); err != nil {
4997 return err
4998 }
4999 if _, err := cw.WriteString(string("artifact")); err != nil {
5000 return err
5001 }
5002
5003 if err := t.Artifact.MarshalCBOR(cw); err != nil {
5004 return err
5005 }
5006
5007 // t.CreatedAt (string) (string)
5008 if len("createdAt") > 1000000 {
5009 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5010 }
5011
5012 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5013 return err
5014 }
5015 if _, err := cw.WriteString(string("createdAt")); err != nil {
5016 return err
5017 }
5018
5019 if len(t.CreatedAt) > 1000000 {
5020 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5021 }
5022
5023 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5024 return err
5025 }
5026 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5027 return err
5028 }
5029 return nil
5030}
5031
5032func (t *RepoArtifact) UnmarshalCBOR(r io.Reader) (err error) {
5033 *t = RepoArtifact{}
5034
5035 cr := cbg.NewCborReader(r)
5036
5037 maj, extra, err := cr.ReadHeader()
5038 if err != nil {
5039 return err
5040 }
5041 defer func() {
5042 if err == io.EOF {
5043 err = io.ErrUnexpectedEOF
5044 }
5045 }()
5046
5047 if maj != cbg.MajMap {
5048 return fmt.Errorf("cbor input should be of type map")
5049 }
5050
5051 if extra > cbg.MaxLength {
5052 return fmt.Errorf("RepoArtifact: map struct too large (%d)", extra)
5053 }
5054
5055 n := extra
5056
5057 nameBuf := make([]byte, 9)
5058 for i := uint64(0); i < n; i++ {
5059 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5060 if err != nil {
5061 return err
5062 }
5063
5064 if !ok {
5065 // Field doesn't exist on this type, so ignore it
5066 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5067 return err
5068 }
5069 continue
5070 }
5071
5072 switch string(nameBuf[:nameLen]) {
5073 // t.Tag (util.LexBytes) (slice)
5074 case "tag":
5075
5076 maj, extra, err = cr.ReadHeader()
5077 if err != nil {
5078 return err
5079 }
5080
5081 if extra > 2097152 {
5082 return fmt.Errorf("t.Tag: byte array too large (%d)", extra)
5083 }
5084 if maj != cbg.MajByteString {
5085 return fmt.Errorf("expected byte array")
5086 }
5087
5088 if extra > 0 {
5089 t.Tag = make([]uint8, extra)
5090 }
5091
5092 if _, err := io.ReadFull(cr, t.Tag); err != nil {
5093 return err
5094 }
5095
5096 // t.Name (string) (string)
5097 case "name":
5098
5099 {
5100 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5101 if err != nil {
5102 return err
5103 }
5104
5105 t.Name = string(sval)
5106 }
5107 // t.Repo (string) (string)
5108 case "repo":
5109
5110 {
5111 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5112 if err != nil {
5113 return err
5114 }
5115
5116 t.Repo = string(sval)
5117 }
5118 // t.LexiconTypeID (string) (string)
5119 case "$type":
5120
5121 {
5122 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5123 if err != nil {
5124 return err
5125 }
5126
5127 t.LexiconTypeID = string(sval)
5128 }
5129 // t.Artifact (util.LexBlob) (struct)
5130 case "artifact":
5131
5132 {
5133
5134 b, err := cr.ReadByte()
5135 if err != nil {
5136 return err
5137 }
5138 if b != cbg.CborNull[0] {
5139 if err := cr.UnreadByte(); err != nil {
5140 return err
5141 }
5142 t.Artifact = new(util.LexBlob)
5143 if err := t.Artifact.UnmarshalCBOR(cr); err != nil {
5144 return xerrors.Errorf("unmarshaling t.Artifact pointer: %w", err)
5145 }
5146 }
5147
5148 }
5149 // t.CreatedAt (string) (string)
5150 case "createdAt":
5151
5152 {
5153 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5154 if err != nil {
5155 return err
5156 }
5157
5158 t.CreatedAt = string(sval)
5159 }
5160
5161 default:
5162 // Field doesn't exist on this type, so ignore it
5163 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5164 return err
5165 }
5166 }
5167 }
5168
5169 return nil
5170}
5171func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error {
5172 if t == nil {
5173 _, err := w.Write(cbg.CborNull)
5174 return err
5175 }
5176
5177 cw := cbg.NewCborWriter(w)
5178 fieldCount := 7
5179
5180 if t.CommentId == nil {
5181 fieldCount--
5182 }
5183
5184 if t.Owner == nil {
5185 fieldCount--
5186 }
5187
5188 if t.Repo == nil {
5189 fieldCount--
5190 }
5191
5192 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5193 return err
5194 }
5195
5196 // t.Body (string) (string)
5197 if len("body") > 1000000 {
5198 return xerrors.Errorf("Value in field \"body\" was too long")
5199 }
5200
5201 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
5202 return err
5203 }
5204 if _, err := cw.WriteString(string("body")); err != nil {
5205 return err
5206 }
5207
5208 if len(t.Body) > 1000000 {
5209 return xerrors.Errorf("Value in field t.Body was too long")
5210 }
5211
5212 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
5213 return err
5214 }
5215 if _, err := cw.WriteString(string(t.Body)); err != nil {
5216 return err
5217 }
5218
5219 // t.Repo (string) (string)
5220 if t.Repo != nil {
5221
5222 if len("repo") > 1000000 {
5223 return xerrors.Errorf("Value in field \"repo\" was too long")
5224 }
5225
5226 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5227 return err
5228 }
5229 if _, err := cw.WriteString(string("repo")); err != nil {
5230 return err
5231 }
5232
5233 if t.Repo == nil {
5234 if _, err := cw.Write(cbg.CborNull); err != nil {
5235 return err
5236 }
5237 } else {
5238 if len(*t.Repo) > 1000000 {
5239 return xerrors.Errorf("Value in field t.Repo was too long")
5240 }
5241
5242 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
5243 return err
5244 }
5245 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
5246 return err
5247 }
5248 }
5249 }
5250
5251 // t.LexiconTypeID (string) (string)
5252 if len("$type") > 1000000 {
5253 return xerrors.Errorf("Value in field \"$type\" was too long")
5254 }
5255
5256 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5257 return err
5258 }
5259 if _, err := cw.WriteString(string("$type")); err != nil {
5260 return err
5261 }
5262
5263 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil {
5264 return err
5265 }
5266 if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil {
5267 return err
5268 }
5269
5270 // t.Issue (string) (string)
5271 if len("issue") > 1000000 {
5272 return xerrors.Errorf("Value in field \"issue\" was too long")
5273 }
5274
5275 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
5276 return err
5277 }
5278 if _, err := cw.WriteString(string("issue")); err != nil {
5279 return err
5280 }
5281
5282 if len(t.Issue) > 1000000 {
5283 return xerrors.Errorf("Value in field t.Issue was too long")
5284 }
5285
5286 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
5287 return err
5288 }
5289 if _, err := cw.WriteString(string(t.Issue)); err != nil {
5290 return err
5291 }
5292
5293 // t.Owner (string) (string)
5294 if t.Owner != nil {
5295
5296 if len("owner") > 1000000 {
5297 return xerrors.Errorf("Value in field \"owner\" was too long")
5298 }
5299
5300 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
5301 return err
5302 }
5303 if _, err := cw.WriteString(string("owner")); err != nil {
5304 return err
5305 }
5306
5307 if t.Owner == nil {
5308 if _, err := cw.Write(cbg.CborNull); err != nil {
5309 return err
5310 }
5311 } else {
5312 if len(*t.Owner) > 1000000 {
5313 return xerrors.Errorf("Value in field t.Owner was too long")
5314 }
5315
5316 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Owner))); err != nil {
5317 return err
5318 }
5319 if _, err := cw.WriteString(string(*t.Owner)); err != nil {
5320 return err
5321 }
5322 }
5323 }
5324
5325 // t.CommentId (int64) (int64)
5326 if t.CommentId != nil {
5327
5328 if len("commentId") > 1000000 {
5329 return xerrors.Errorf("Value in field \"commentId\" was too long")
5330 }
5331
5332 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commentId"))); err != nil {
5333 return err
5334 }
5335 if _, err := cw.WriteString(string("commentId")); err != nil {
5336 return err
5337 }
5338
5339 if t.CommentId == nil {
5340 if _, err := cw.Write(cbg.CborNull); err != nil {
5341 return err
5342 }
5343 } else {
5344 if *t.CommentId >= 0 {
5345 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.CommentId)); err != nil {
5346 return err
5347 }
5348 } else {
5349 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.CommentId-1)); err != nil {
5350 return err
5351 }
5352 }
5353 }
5354
5355 }
5356
5357 // t.CreatedAt (string) (string)
5358 if len("createdAt") > 1000000 {
5359 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5360 }
5361
5362 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5363 return err
5364 }
5365 if _, err := cw.WriteString(string("createdAt")); err != nil {
5366 return err
5367 }
5368
5369 if len(t.CreatedAt) > 1000000 {
5370 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5371 }
5372
5373 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5374 return err
5375 }
5376 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5377 return err
5378 }
5379 return nil
5380}
5381
5382func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) {
5383 *t = RepoIssueComment{}
5384
5385 cr := cbg.NewCborReader(r)
5386
5387 maj, extra, err := cr.ReadHeader()
5388 if err != nil {
5389 return err
5390 }
5391 defer func() {
5392 if err == io.EOF {
5393 err = io.ErrUnexpectedEOF
5394 }
5395 }()
5396
5397 if maj != cbg.MajMap {
5398 return fmt.Errorf("cbor input should be of type map")
5399 }
5400
5401 if extra > cbg.MaxLength {
5402 return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra)
5403 }
5404
5405 n := extra
5406
5407 nameBuf := make([]byte, 9)
5408 for i := uint64(0); i < n; i++ {
5409 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5410 if err != nil {
5411 return err
5412 }
5413
5414 if !ok {
5415 // Field doesn't exist on this type, so ignore it
5416 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5417 return err
5418 }
5419 continue
5420 }
5421
5422 switch string(nameBuf[:nameLen]) {
5423 // t.Body (string) (string)
5424 case "body":
5425
5426 {
5427 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5428 if err != nil {
5429 return err
5430 }
5431
5432 t.Body = string(sval)
5433 }
5434 // t.Repo (string) (string)
5435 case "repo":
5436
5437 {
5438 b, err := cr.ReadByte()
5439 if err != nil {
5440 return err
5441 }
5442 if b != cbg.CborNull[0] {
5443 if err := cr.UnreadByte(); err != nil {
5444 return err
5445 }
5446
5447 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5448 if err != nil {
5449 return err
5450 }
5451
5452 t.Repo = (*string)(&sval)
5453 }
5454 }
5455 // t.LexiconTypeID (string) (string)
5456 case "$type":
5457
5458 {
5459 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5460 if err != nil {
5461 return err
5462 }
5463
5464 t.LexiconTypeID = string(sval)
5465 }
5466 // t.Issue (string) (string)
5467 case "issue":
5468
5469 {
5470 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5471 if err != nil {
5472 return err
5473 }
5474
5475 t.Issue = string(sval)
5476 }
5477 // t.Owner (string) (string)
5478 case "owner":
5479
5480 {
5481 b, err := cr.ReadByte()
5482 if err != nil {
5483 return err
5484 }
5485 if b != cbg.CborNull[0] {
5486 if err := cr.UnreadByte(); err != nil {
5487 return err
5488 }
5489
5490 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5491 if err != nil {
5492 return err
5493 }
5494
5495 t.Owner = (*string)(&sval)
5496 }
5497 }
5498 // t.CommentId (int64) (int64)
5499 case "commentId":
5500 {
5501
5502 b, err := cr.ReadByte()
5503 if err != nil {
5504 return err
5505 }
5506 if b != cbg.CborNull[0] {
5507 if err := cr.UnreadByte(); err != nil {
5508 return err
5509 }
5510 maj, extra, err := cr.ReadHeader()
5511 if err != nil {
5512 return err
5513 }
5514 var extraI int64
5515 switch maj {
5516 case cbg.MajUnsignedInt:
5517 extraI = int64(extra)
5518 if extraI < 0 {
5519 return fmt.Errorf("int64 positive overflow")
5520 }
5521 case cbg.MajNegativeInt:
5522 extraI = int64(extra)
5523 if extraI < 0 {
5524 return fmt.Errorf("int64 negative overflow")
5525 }
5526 extraI = -1 - extraI
5527 default:
5528 return fmt.Errorf("wrong type for int64 field: %d", maj)
5529 }
5530
5531 t.CommentId = (*int64)(&extraI)
5532 }
5533 }
5534 // t.CreatedAt (string) (string)
5535 case "createdAt":
5536
5537 {
5538 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5539 if err != nil {
5540 return err
5541 }
5542
5543 t.CreatedAt = string(sval)
5544 }
5545
5546 default:
5547 // Field doesn't exist on this type, so ignore it
5548 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5549 return err
5550 }
5551 }
5552 }
5553
5554 return nil
5555}
5556func (t *RepoIssueState) MarshalCBOR(w io.Writer) error {
5557 if t == nil {
5558 _, err := w.Write(cbg.CborNull)
5559 return err
5560 }
5561
5562 cw := cbg.NewCborWriter(w)
5563
5564 if _, err := cw.Write([]byte{163}); err != nil {
5565 return err
5566 }
5567
5568 // t.LexiconTypeID (string) (string)
5569 if len("$type") > 1000000 {
5570 return xerrors.Errorf("Value in field \"$type\" was too long")
5571 }
5572
5573 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5574 return err
5575 }
5576 if _, err := cw.WriteString(string("$type")); err != nil {
5577 return err
5578 }
5579
5580 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil {
5581 return err
5582 }
5583 if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil {
5584 return err
5585 }
5586
5587 // t.Issue (string) (string)
5588 if len("issue") > 1000000 {
5589 return xerrors.Errorf("Value in field \"issue\" was too long")
5590 }
5591
5592 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
5593 return err
5594 }
5595 if _, err := cw.WriteString(string("issue")); err != nil {
5596 return err
5597 }
5598
5599 if len(t.Issue) > 1000000 {
5600 return xerrors.Errorf("Value in field t.Issue was too long")
5601 }
5602
5603 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
5604 return err
5605 }
5606 if _, err := cw.WriteString(string(t.Issue)); err != nil {
5607 return err
5608 }
5609
5610 // t.State (string) (string)
5611 if len("state") > 1000000 {
5612 return xerrors.Errorf("Value in field \"state\" was too long")
5613 }
5614
5615 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil {
5616 return err
5617 }
5618 if _, err := cw.WriteString(string("state")); err != nil {
5619 return err
5620 }
5621
5622 if len(t.State) > 1000000 {
5623 return xerrors.Errorf("Value in field t.State was too long")
5624 }
5625
5626 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil {
5627 return err
5628 }
5629 if _, err := cw.WriteString(string(t.State)); err != nil {
5630 return err
5631 }
5632 return nil
5633}
5634
5635func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) {
5636 *t = RepoIssueState{}
5637
5638 cr := cbg.NewCborReader(r)
5639
5640 maj, extra, err := cr.ReadHeader()
5641 if err != nil {
5642 return err
5643 }
5644 defer func() {
5645 if err == io.EOF {
5646 err = io.ErrUnexpectedEOF
5647 }
5648 }()
5649
5650 if maj != cbg.MajMap {
5651 return fmt.Errorf("cbor input should be of type map")
5652 }
5653
5654 if extra > cbg.MaxLength {
5655 return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra)
5656 }
5657
5658 n := extra
5659
5660 nameBuf := make([]byte, 5)
5661 for i := uint64(0); i < n; i++ {
5662 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5663 if err != nil {
5664 return err
5665 }
5666
5667 if !ok {
5668 // Field doesn't exist on this type, so ignore it
5669 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5670 return err
5671 }
5672 continue
5673 }
5674
5675 switch string(nameBuf[:nameLen]) {
5676 // t.LexiconTypeID (string) (string)
5677 case "$type":
5678
5679 {
5680 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5681 if err != nil {
5682 return err
5683 }
5684
5685 t.LexiconTypeID = string(sval)
5686 }
5687 // t.Issue (string) (string)
5688 case "issue":
5689
5690 {
5691 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5692 if err != nil {
5693 return err
5694 }
5695
5696 t.Issue = string(sval)
5697 }
5698 // t.State (string) (string)
5699 case "state":
5700
5701 {
5702 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5703 if err != nil {
5704 return err
5705 }
5706
5707 t.State = string(sval)
5708 }
5709
5710 default:
5711 // Field doesn't exist on this type, so ignore it
5712 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5713 return err
5714 }
5715 }
5716 }
5717
5718 return nil
5719}
5720func (t *RepoIssue) MarshalCBOR(w io.Writer) error {
5721 if t == nil {
5722 _, err := w.Write(cbg.CborNull)
5723 return err
5724 }
5725
5726 cw := cbg.NewCborWriter(w)
5727 fieldCount := 7
5728
5729 if t.Body == nil {
5730 fieldCount--
5731 }
5732
5733 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5734 return err
5735 }
5736
5737 // t.Body (string) (string)
5738 if t.Body != nil {
5739
5740 if len("body") > 1000000 {
5741 return xerrors.Errorf("Value in field \"body\" was too long")
5742 }
5743
5744 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
5745 return err
5746 }
5747 if _, err := cw.WriteString(string("body")); err != nil {
5748 return err
5749 }
5750
5751 if t.Body == nil {
5752 if _, err := cw.Write(cbg.CborNull); err != nil {
5753 return err
5754 }
5755 } else {
5756 if len(*t.Body) > 1000000 {
5757 return xerrors.Errorf("Value in field t.Body was too long")
5758 }
5759
5760 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
5761 return err
5762 }
5763 if _, err := cw.WriteString(string(*t.Body)); err != nil {
5764 return err
5765 }
5766 }
5767 }
5768
5769 // t.Repo (string) (string)
5770 if len("repo") > 1000000 {
5771 return xerrors.Errorf("Value in field \"repo\" was too long")
5772 }
5773
5774 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5775 return err
5776 }
5777 if _, err := cw.WriteString(string("repo")); err != nil {
5778 return err
5779 }
5780
5781 if len(t.Repo) > 1000000 {
5782 return xerrors.Errorf("Value in field t.Repo was too long")
5783 }
5784
5785 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
5786 return err
5787 }
5788 if _, err := cw.WriteString(string(t.Repo)); err != nil {
5789 return err
5790 }
5791
5792 // t.LexiconTypeID (string) (string)
5793 if len("$type") > 1000000 {
5794 return xerrors.Errorf("Value in field \"$type\" was too long")
5795 }
5796
5797 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5798 return err
5799 }
5800 if _, err := cw.WriteString(string("$type")); err != nil {
5801 return err
5802 }
5803
5804 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil {
5805 return err
5806 }
5807 if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil {
5808 return err
5809 }
5810
5811 // t.Owner (string) (string)
5812 if len("owner") > 1000000 {
5813 return xerrors.Errorf("Value in field \"owner\" was too long")
5814 }
5815
5816 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
5817 return err
5818 }
5819 if _, err := cw.WriteString(string("owner")); err != nil {
5820 return err
5821 }
5822
5823 if len(t.Owner) > 1000000 {
5824 return xerrors.Errorf("Value in field t.Owner was too long")
5825 }
5826
5827 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {
5828 return err
5829 }
5830 if _, err := cw.WriteString(string(t.Owner)); err != nil {
5831 return err
5832 }
5833
5834 // t.Title (string) (string)
5835 if len("title") > 1000000 {
5836 return xerrors.Errorf("Value in field \"title\" was too long")
5837 }
5838
5839 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
5840 return err
5841 }
5842 if _, err := cw.WriteString(string("title")); err != nil {
5843 return err
5844 }
5845
5846 if len(t.Title) > 1000000 {
5847 return xerrors.Errorf("Value in field t.Title was too long")
5848 }
5849
5850 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
5851 return err
5852 }
5853 if _, err := cw.WriteString(string(t.Title)); err != nil {
5854 return err
5855 }
5856
5857 // t.IssueId (int64) (int64)
5858 if len("issueId") > 1000000 {
5859 return xerrors.Errorf("Value in field \"issueId\" was too long")
5860 }
5861
5862 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issueId"))); err != nil {
5863 return err
5864 }
5865 if _, err := cw.WriteString(string("issueId")); err != nil {
5866 return err
5867 }
5868
5869 if t.IssueId >= 0 {
5870 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.IssueId)); err != nil {
5871 return err
5872 }
5873 } else {
5874 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.IssueId-1)); err != nil {
5875 return err
5876 }
5877 }
5878
5879 // t.CreatedAt (string) (string)
5880 if len("createdAt") > 1000000 {
5881 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5882 }
5883
5884 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5885 return err
5886 }
5887 if _, err := cw.WriteString(string("createdAt")); err != nil {
5888 return err
5889 }
5890
5891 if len(t.CreatedAt) > 1000000 {
5892 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5893 }
5894
5895 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5896 return err
5897 }
5898 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5899 return err
5900 }
5901 return nil
5902}
5903
5904func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) {
5905 *t = RepoIssue{}
5906
5907 cr := cbg.NewCborReader(r)
5908
5909 maj, extra, err := cr.ReadHeader()
5910 if err != nil {
5911 return err
5912 }
5913 defer func() {
5914 if err == io.EOF {
5915 err = io.ErrUnexpectedEOF
5916 }
5917 }()
5918
5919 if maj != cbg.MajMap {
5920 return fmt.Errorf("cbor input should be of type map")
5921 }
5922
5923 if extra > cbg.MaxLength {
5924 return fmt.Errorf("RepoIssue: map struct too large (%d)", extra)
5925 }
5926
5927 n := extra
5928
5929 nameBuf := make([]byte, 9)
5930 for i := uint64(0); i < n; i++ {
5931 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5932 if err != nil {
5933 return err
5934 }
5935
5936 if !ok {
5937 // Field doesn't exist on this type, so ignore it
5938 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5939 return err
5940 }
5941 continue
5942 }
5943
5944 switch string(nameBuf[:nameLen]) {
5945 // t.Body (string) (string)
5946 case "body":
5947
5948 {
5949 b, err := cr.ReadByte()
5950 if err != nil {
5951 return err
5952 }
5953 if b != cbg.CborNull[0] {
5954 if err := cr.UnreadByte(); err != nil {
5955 return err
5956 }
5957
5958 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5959 if err != nil {
5960 return err
5961 }
5962
5963 t.Body = (*string)(&sval)
5964 }
5965 }
5966 // t.Repo (string) (string)
5967 case "repo":
5968
5969 {
5970 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5971 if err != nil {
5972 return err
5973 }
5974
5975 t.Repo = string(sval)
5976 }
5977 // t.LexiconTypeID (string) (string)
5978 case "$type":
5979
5980 {
5981 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5982 if err != nil {
5983 return err
5984 }
5985
5986 t.LexiconTypeID = string(sval)
5987 }
5988 // t.Owner (string) (string)
5989 case "owner":
5990
5991 {
5992 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5993 if err != nil {
5994 return err
5995 }
5996
5997 t.Owner = string(sval)
5998 }
5999 // t.Title (string) (string)
6000 case "title":
6001
6002 {
6003 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6004 if err != nil {
6005 return err
6006 }
6007
6008 t.Title = string(sval)
6009 }
6010 // t.IssueId (int64) (int64)
6011 case "issueId":
6012 {
6013 maj, extra, err := cr.ReadHeader()
6014 if err != nil {
6015 return err
6016 }
6017 var extraI int64
6018 switch maj {
6019 case cbg.MajUnsignedInt:
6020 extraI = int64(extra)
6021 if extraI < 0 {
6022 return fmt.Errorf("int64 positive overflow")
6023 }
6024 case cbg.MajNegativeInt:
6025 extraI = int64(extra)
6026 if extraI < 0 {
6027 return fmt.Errorf("int64 negative overflow")
6028 }
6029 extraI = -1 - extraI
6030 default:
6031 return fmt.Errorf("wrong type for int64 field: %d", maj)
6032 }
6033
6034 t.IssueId = int64(extraI)
6035 }
6036 // t.CreatedAt (string) (string)
6037 case "createdAt":
6038
6039 {
6040 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6041 if err != nil {
6042 return err
6043 }
6044
6045 t.CreatedAt = string(sval)
6046 }
6047
6048 default:
6049 // Field doesn't exist on this type, so ignore it
6050 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6051 return err
6052 }
6053 }
6054 }
6055
6056 return nil
6057}
6058func (t *RepoPullComment) MarshalCBOR(w io.Writer) error {
6059 if t == nil {
6060 _, err := w.Write(cbg.CborNull)
6061 return err
6062 }
6063
6064 cw := cbg.NewCborWriter(w)
6065 fieldCount := 7
6066
6067 if t.CommentId == nil {
6068 fieldCount--
6069 }
6070
6071 if t.Owner == nil {
6072 fieldCount--
6073 }
6074
6075 if t.Repo == nil {
6076 fieldCount--
6077 }
6078
6079 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6080 return err
6081 }
6082
6083 // t.Body (string) (string)
6084 if len("body") > 1000000 {
6085 return xerrors.Errorf("Value in field \"body\" was too long")
6086 }
6087
6088 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
6089 return err
6090 }
6091 if _, err := cw.WriteString(string("body")); err != nil {
6092 return err
6093 }
6094
6095 if len(t.Body) > 1000000 {
6096 return xerrors.Errorf("Value in field t.Body was too long")
6097 }
6098
6099 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
6100 return err
6101 }
6102 if _, err := cw.WriteString(string(t.Body)); err != nil {
6103 return err
6104 }
6105
6106 // t.Pull (string) (string)
6107 if len("pull") > 1000000 {
6108 return xerrors.Errorf("Value in field \"pull\" was too long")
6109 }
6110
6111 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
6112 return err
6113 }
6114 if _, err := cw.WriteString(string("pull")); err != nil {
6115 return err
6116 }
6117
6118 if len(t.Pull) > 1000000 {
6119 return xerrors.Errorf("Value in field t.Pull was too long")
6120 }
6121
6122 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
6123 return err
6124 }
6125 if _, err := cw.WriteString(string(t.Pull)); err != nil {
6126 return err
6127 }
6128
6129 // t.Repo (string) (string)
6130 if t.Repo != nil {
6131
6132 if len("repo") > 1000000 {
6133 return xerrors.Errorf("Value in field \"repo\" was too long")
6134 }
6135
6136 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6137 return err
6138 }
6139 if _, err := cw.WriteString(string("repo")); err != nil {
6140 return err
6141 }
6142
6143 if t.Repo == nil {
6144 if _, err := cw.Write(cbg.CborNull); err != nil {
6145 return err
6146 }
6147 } else {
6148 if len(*t.Repo) > 1000000 {
6149 return xerrors.Errorf("Value in field t.Repo was too long")
6150 }
6151
6152 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
6153 return err
6154 }
6155 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
6156 return err
6157 }
6158 }
6159 }
6160
6161 // t.LexiconTypeID (string) (string)
6162 if len("$type") > 1000000 {
6163 return xerrors.Errorf("Value in field \"$type\" was too long")
6164 }
6165
6166 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6167 return err
6168 }
6169 if _, err := cw.WriteString(string("$type")); err != nil {
6170 return err
6171 }
6172
6173 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.comment"))); err != nil {
6174 return err
6175 }
6176 if _, err := cw.WriteString(string("sh.tangled.repo.pull.comment")); err != nil {
6177 return err
6178 }
6179
6180 // t.Owner (string) (string)
6181 if t.Owner != nil {
6182
6183 if len("owner") > 1000000 {
6184 return xerrors.Errorf("Value in field \"owner\" was too long")
6185 }
6186
6187 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
6188 return err
6189 }
6190 if _, err := cw.WriteString(string("owner")); err != nil {
6191 return err
6192 }
6193
6194 if t.Owner == nil {
6195 if _, err := cw.Write(cbg.CborNull); err != nil {
6196 return err
6197 }
6198 } else {
6199 if len(*t.Owner) > 1000000 {
6200 return xerrors.Errorf("Value in field t.Owner was too long")
6201 }
6202
6203 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Owner))); err != nil {
6204 return err
6205 }
6206 if _, err := cw.WriteString(string(*t.Owner)); err != nil {
6207 return err
6208 }
6209 }
6210 }
6211
6212 // t.CommentId (int64) (int64)
6213 if t.CommentId != nil {
6214
6215 if len("commentId") > 1000000 {
6216 return xerrors.Errorf("Value in field \"commentId\" was too long")
6217 }
6218
6219 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commentId"))); err != nil {
6220 return err
6221 }
6222 if _, err := cw.WriteString(string("commentId")); err != nil {
6223 return err
6224 }
6225
6226 if t.CommentId == nil {
6227 if _, err := cw.Write(cbg.CborNull); err != nil {
6228 return err
6229 }
6230 } else {
6231 if *t.CommentId >= 0 {
6232 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.CommentId)); err != nil {
6233 return err
6234 }
6235 } else {
6236 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.CommentId-1)); err != nil {
6237 return err
6238 }
6239 }
6240 }
6241
6242 }
6243
6244 // t.CreatedAt (string) (string)
6245 if len("createdAt") > 1000000 {
6246 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6247 }
6248
6249 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6250 return err
6251 }
6252 if _, err := cw.WriteString(string("createdAt")); err != nil {
6253 return err
6254 }
6255
6256 if len(t.CreatedAt) > 1000000 {
6257 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6258 }
6259
6260 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6261 return err
6262 }
6263 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6264 return err
6265 }
6266 return nil
6267}
6268
6269func (t *RepoPullComment) UnmarshalCBOR(r io.Reader) (err error) {
6270 *t = RepoPullComment{}
6271
6272 cr := cbg.NewCborReader(r)
6273
6274 maj, extra, err := cr.ReadHeader()
6275 if err != nil {
6276 return err
6277 }
6278 defer func() {
6279 if err == io.EOF {
6280 err = io.ErrUnexpectedEOF
6281 }
6282 }()
6283
6284 if maj != cbg.MajMap {
6285 return fmt.Errorf("cbor input should be of type map")
6286 }
6287
6288 if extra > cbg.MaxLength {
6289 return fmt.Errorf("RepoPullComment: map struct too large (%d)", extra)
6290 }
6291
6292 n := extra
6293
6294 nameBuf := make([]byte, 9)
6295 for i := uint64(0); i < n; i++ {
6296 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6297 if err != nil {
6298 return err
6299 }
6300
6301 if !ok {
6302 // Field doesn't exist on this type, so ignore it
6303 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6304 return err
6305 }
6306 continue
6307 }
6308
6309 switch string(nameBuf[:nameLen]) {
6310 // t.Body (string) (string)
6311 case "body":
6312
6313 {
6314 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6315 if err != nil {
6316 return err
6317 }
6318
6319 t.Body = string(sval)
6320 }
6321 // t.Pull (string) (string)
6322 case "pull":
6323
6324 {
6325 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6326 if err != nil {
6327 return err
6328 }
6329
6330 t.Pull = string(sval)
6331 }
6332 // t.Repo (string) (string)
6333 case "repo":
6334
6335 {
6336 b, err := cr.ReadByte()
6337 if err != nil {
6338 return err
6339 }
6340 if b != cbg.CborNull[0] {
6341 if err := cr.UnreadByte(); err != nil {
6342 return err
6343 }
6344
6345 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6346 if err != nil {
6347 return err
6348 }
6349
6350 t.Repo = (*string)(&sval)
6351 }
6352 }
6353 // t.LexiconTypeID (string) (string)
6354 case "$type":
6355
6356 {
6357 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6358 if err != nil {
6359 return err
6360 }
6361
6362 t.LexiconTypeID = string(sval)
6363 }
6364 // t.Owner (string) (string)
6365 case "owner":
6366
6367 {
6368 b, err := cr.ReadByte()
6369 if err != nil {
6370 return err
6371 }
6372 if b != cbg.CborNull[0] {
6373 if err := cr.UnreadByte(); err != nil {
6374 return err
6375 }
6376
6377 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6378 if err != nil {
6379 return err
6380 }
6381
6382 t.Owner = (*string)(&sval)
6383 }
6384 }
6385 // t.CommentId (int64) (int64)
6386 case "commentId":
6387 {
6388
6389 b, err := cr.ReadByte()
6390 if err != nil {
6391 return err
6392 }
6393 if b != cbg.CborNull[0] {
6394 if err := cr.UnreadByte(); err != nil {
6395 return err
6396 }
6397 maj, extra, err := cr.ReadHeader()
6398 if err != nil {
6399 return err
6400 }
6401 var extraI int64
6402 switch maj {
6403 case cbg.MajUnsignedInt:
6404 extraI = int64(extra)
6405 if extraI < 0 {
6406 return fmt.Errorf("int64 positive overflow")
6407 }
6408 case cbg.MajNegativeInt:
6409 extraI = int64(extra)
6410 if extraI < 0 {
6411 return fmt.Errorf("int64 negative overflow")
6412 }
6413 extraI = -1 - extraI
6414 default:
6415 return fmt.Errorf("wrong type for int64 field: %d", maj)
6416 }
6417
6418 t.CommentId = (*int64)(&extraI)
6419 }
6420 }
6421 // t.CreatedAt (string) (string)
6422 case "createdAt":
6423
6424 {
6425 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6426 if err != nil {
6427 return err
6428 }
6429
6430 t.CreatedAt = string(sval)
6431 }
6432
6433 default:
6434 // Field doesn't exist on this type, so ignore it
6435 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6436 return err
6437 }
6438 }
6439 }
6440
6441 return nil
6442}
6443func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error {
6444 if t == nil {
6445 _, err := w.Write(cbg.CborNull)
6446 return err
6447 }
6448
6449 cw := cbg.NewCborWriter(w)
6450
6451 if _, err := cw.Write([]byte{163}); err != nil {
6452 return err
6453 }
6454
6455 // t.Pull (string) (string)
6456 if len("pull") > 1000000 {
6457 return xerrors.Errorf("Value in field \"pull\" was too long")
6458 }
6459
6460 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
6461 return err
6462 }
6463 if _, err := cw.WriteString(string("pull")); err != nil {
6464 return err
6465 }
6466
6467 if len(t.Pull) > 1000000 {
6468 return xerrors.Errorf("Value in field t.Pull was too long")
6469 }
6470
6471 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
6472 return err
6473 }
6474 if _, err := cw.WriteString(string(t.Pull)); err != nil {
6475 return err
6476 }
6477
6478 // t.LexiconTypeID (string) (string)
6479 if len("$type") > 1000000 {
6480 return xerrors.Errorf("Value in field \"$type\" was too long")
6481 }
6482
6483 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6484 return err
6485 }
6486 if _, err := cw.WriteString(string("$type")); err != nil {
6487 return err
6488 }
6489
6490 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil {
6491 return err
6492 }
6493 if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil {
6494 return err
6495 }
6496
6497 // t.Status (string) (string)
6498 if len("status") > 1000000 {
6499 return xerrors.Errorf("Value in field \"status\" was too long")
6500 }
6501
6502 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
6503 return err
6504 }
6505 if _, err := cw.WriteString(string("status")); err != nil {
6506 return err
6507 }
6508
6509 if len(t.Status) > 1000000 {
6510 return xerrors.Errorf("Value in field t.Status was too long")
6511 }
6512
6513 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
6514 return err
6515 }
6516 if _, err := cw.WriteString(string(t.Status)); err != nil {
6517 return err
6518 }
6519 return nil
6520}
6521
6522func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) {
6523 *t = RepoPullStatus{}
6524
6525 cr := cbg.NewCborReader(r)
6526
6527 maj, extra, err := cr.ReadHeader()
6528 if err != nil {
6529 return err
6530 }
6531 defer func() {
6532 if err == io.EOF {
6533 err = io.ErrUnexpectedEOF
6534 }
6535 }()
6536
6537 if maj != cbg.MajMap {
6538 return fmt.Errorf("cbor input should be of type map")
6539 }
6540
6541 if extra > cbg.MaxLength {
6542 return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra)
6543 }
6544
6545 n := extra
6546
6547 nameBuf := make([]byte, 6)
6548 for i := uint64(0); i < n; i++ {
6549 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6550 if err != nil {
6551 return err
6552 }
6553
6554 if !ok {
6555 // Field doesn't exist on this type, so ignore it
6556 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6557 return err
6558 }
6559 continue
6560 }
6561
6562 switch string(nameBuf[:nameLen]) {
6563 // t.Pull (string) (string)
6564 case "pull":
6565
6566 {
6567 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6568 if err != nil {
6569 return err
6570 }
6571
6572 t.Pull = string(sval)
6573 }
6574 // t.LexiconTypeID (string) (string)
6575 case "$type":
6576
6577 {
6578 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6579 if err != nil {
6580 return err
6581 }
6582
6583 t.LexiconTypeID = string(sval)
6584 }
6585 // t.Status (string) (string)
6586 case "status":
6587
6588 {
6589 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6590 if err != nil {
6591 return err
6592 }
6593
6594 t.Status = string(sval)
6595 }
6596
6597 default:
6598 // Field doesn't exist on this type, so ignore it
6599 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6600 return err
6601 }
6602 }
6603 }
6604
6605 return nil
6606}
6607func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error {
6608 if t == nil {
6609 _, err := w.Write(cbg.CborNull)
6610 return err
6611 }
6612
6613 cw := cbg.NewCborWriter(w)
6614 fieldCount := 2
6615
6616 if t.Repo == nil {
6617 fieldCount--
6618 }
6619
6620 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6621 return err
6622 }
6623
6624 // t.Repo (string) (string)
6625 if t.Repo != nil {
6626
6627 if len("repo") > 1000000 {
6628 return xerrors.Errorf("Value in field \"repo\" was too long")
6629 }
6630
6631 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6632 return err
6633 }
6634 if _, err := cw.WriteString(string("repo")); err != nil {
6635 return err
6636 }
6637
6638 if t.Repo == nil {
6639 if _, err := cw.Write(cbg.CborNull); err != nil {
6640 return err
6641 }
6642 } else {
6643 if len(*t.Repo) > 1000000 {
6644 return xerrors.Errorf("Value in field t.Repo was too long")
6645 }
6646
6647 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
6648 return err
6649 }
6650 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
6651 return err
6652 }
6653 }
6654 }
6655
6656 // t.Branch (string) (string)
6657 if len("branch") > 1000000 {
6658 return xerrors.Errorf("Value in field \"branch\" was too long")
6659 }
6660
6661 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
6662 return err
6663 }
6664 if _, err := cw.WriteString(string("branch")); err != nil {
6665 return err
6666 }
6667
6668 if len(t.Branch) > 1000000 {
6669 return xerrors.Errorf("Value in field t.Branch was too long")
6670 }
6671
6672 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
6673 return err
6674 }
6675 if _, err := cw.WriteString(string(t.Branch)); err != nil {
6676 return err
6677 }
6678 return nil
6679}
6680
6681func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) {
6682 *t = RepoPull_Source{}
6683
6684 cr := cbg.NewCborReader(r)
6685
6686 maj, extra, err := cr.ReadHeader()
6687 if err != nil {
6688 return err
6689 }
6690 defer func() {
6691 if err == io.EOF {
6692 err = io.ErrUnexpectedEOF
6693 }
6694 }()
6695
6696 if maj != cbg.MajMap {
6697 return fmt.Errorf("cbor input should be of type map")
6698 }
6699
6700 if extra > cbg.MaxLength {
6701 return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra)
6702 }
6703
6704 n := extra
6705
6706 nameBuf := make([]byte, 6)
6707 for i := uint64(0); i < n; i++ {
6708 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6709 if err != nil {
6710 return err
6711 }
6712
6713 if !ok {
6714 // Field doesn't exist on this type, so ignore it
6715 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6716 return err
6717 }
6718 continue
6719 }
6720
6721 switch string(nameBuf[:nameLen]) {
6722 // t.Repo (string) (string)
6723 case "repo":
6724
6725 {
6726 b, err := cr.ReadByte()
6727 if err != nil {
6728 return err
6729 }
6730 if b != cbg.CborNull[0] {
6731 if err := cr.UnreadByte(); err != nil {
6732 return err
6733 }
6734
6735 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6736 if err != nil {
6737 return err
6738 }
6739
6740 t.Repo = (*string)(&sval)
6741 }
6742 }
6743 // t.Branch (string) (string)
6744 case "branch":
6745
6746 {
6747 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6748 if err != nil {
6749 return err
6750 }
6751
6752 t.Branch = string(sval)
6753 }
6754
6755 default:
6756 // Field doesn't exist on this type, so ignore it
6757 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6758 return err
6759 }
6760 }
6761 }
6762
6763 return nil
6764}
6765func (t *RepoPull) MarshalCBOR(w io.Writer) error {
6766 if t == nil {
6767 _, err := w.Write(cbg.CborNull)
6768 return err
6769 }
6770
6771 cw := cbg.NewCborWriter(w)
6772 fieldCount := 9
6773
6774 if t.Body == nil {
6775 fieldCount--
6776 }
6777
6778 if t.Source == nil {
6779 fieldCount--
6780 }
6781
6782 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6783 return err
6784 }
6785
6786 // t.Body (string) (string)
6787 if t.Body != nil {
6788
6789 if len("body") > 1000000 {
6790 return xerrors.Errorf("Value in field \"body\" was too long")
6791 }
6792
6793 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
6794 return err
6795 }
6796 if _, err := cw.WriteString(string("body")); err != nil {
6797 return err
6798 }
6799
6800 if t.Body == nil {
6801 if _, err := cw.Write(cbg.CborNull); err != nil {
6802 return err
6803 }
6804 } else {
6805 if len(*t.Body) > 1000000 {
6806 return xerrors.Errorf("Value in field t.Body was too long")
6807 }
6808
6809 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
6810 return err
6811 }
6812 if _, err := cw.WriteString(string(*t.Body)); err != nil {
6813 return err
6814 }
6815 }
6816 }
6817
6818 // t.LexiconTypeID (string) (string)
6819 if len("$type") > 1000000 {
6820 return xerrors.Errorf("Value in field \"$type\" was too long")
6821 }
6822
6823 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6824 return err
6825 }
6826 if _, err := cw.WriteString(string("$type")); err != nil {
6827 return err
6828 }
6829
6830 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil {
6831 return err
6832 }
6833 if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil {
6834 return err
6835 }
6836
6837 // t.Patch (string) (string)
6838 if len("patch") > 1000000 {
6839 return xerrors.Errorf("Value in field \"patch\" was too long")
6840 }
6841
6842 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil {
6843 return err
6844 }
6845 if _, err := cw.WriteString(string("patch")); err != nil {
6846 return err
6847 }
6848
6849 if len(t.Patch) > 1000000 {
6850 return xerrors.Errorf("Value in field t.Patch was too long")
6851 }
6852
6853 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Patch))); err != nil {
6854 return err
6855 }
6856 if _, err := cw.WriteString(string(t.Patch)); err != nil {
6857 return err
6858 }
6859
6860 // t.Title (string) (string)
6861 if len("title") > 1000000 {
6862 return xerrors.Errorf("Value in field \"title\" was too long")
6863 }
6864
6865 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
6866 return err
6867 }
6868 if _, err := cw.WriteString(string("title")); err != nil {
6869 return err
6870 }
6871
6872 if len(t.Title) > 1000000 {
6873 return xerrors.Errorf("Value in field t.Title was too long")
6874 }
6875
6876 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
6877 return err
6878 }
6879 if _, err := cw.WriteString(string(t.Title)); err != nil {
6880 return err
6881 }
6882
6883 // t.PullId (int64) (int64)
6884 if len("pullId") > 1000000 {
6885 return xerrors.Errorf("Value in field \"pullId\" was too long")
6886 }
6887
6888 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullId"))); err != nil {
6889 return err
6890 }
6891 if _, err := cw.WriteString(string("pullId")); err != nil {
6892 return err
6893 }
6894
6895 if t.PullId >= 0 {
6896 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.PullId)); err != nil {
6897 return err
6898 }
6899 } else {
6900 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.PullId-1)); err != nil {
6901 return err
6902 }
6903 }
6904
6905 // t.Source (tangled.RepoPull_Source) (struct)
6906 if t.Source != nil {
6907
6908 if len("source") > 1000000 {
6909 return xerrors.Errorf("Value in field \"source\" was too long")
6910 }
6911
6912 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
6913 return err
6914 }
6915 if _, err := cw.WriteString(string("source")); err != nil {
6916 return err
6917 }
6918
6919 if err := t.Source.MarshalCBOR(cw); err != nil {
6920 return err
6921 }
6922 }
6923
6924 // t.CreatedAt (string) (string)
6925 if len("createdAt") > 1000000 {
6926 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6927 }
6928
6929 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6930 return err
6931 }
6932 if _, err := cw.WriteString(string("createdAt")); err != nil {
6933 return err
6934 }
6935
6936 if len(t.CreatedAt) > 1000000 {
6937 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6938 }
6939
6940 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6941 return err
6942 }
6943 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6944 return err
6945 }
6946
6947 // t.TargetRepo (string) (string)
6948 if len("targetRepo") > 1000000 {
6949 return xerrors.Errorf("Value in field \"targetRepo\" was too long")
6950 }
6951
6952 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetRepo"))); err != nil {
6953 return err
6954 }
6955 if _, err := cw.WriteString(string("targetRepo")); err != nil {
6956 return err
6957 }
6958
6959 if len(t.TargetRepo) > 1000000 {
6960 return xerrors.Errorf("Value in field t.TargetRepo was too long")
6961 }
6962
6963 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetRepo))); err != nil {
6964 return err
6965 }
6966 if _, err := cw.WriteString(string(t.TargetRepo)); err != nil {
6967 return err
6968 }
6969
6970 // t.TargetBranch (string) (string)
6971 if len("targetBranch") > 1000000 {
6972 return xerrors.Errorf("Value in field \"targetBranch\" was too long")
6973 }
6974
6975 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil {
6976 return err
6977 }
6978 if _, err := cw.WriteString(string("targetBranch")); err != nil {
6979 return err
6980 }
6981
6982 if len(t.TargetBranch) > 1000000 {
6983 return xerrors.Errorf("Value in field t.TargetBranch was too long")
6984 }
6985
6986 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil {
6987 return err
6988 }
6989 if _, err := cw.WriteString(string(t.TargetBranch)); err != nil {
6990 return err
6991 }
6992 return nil
6993}
6994
6995func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) {
6996 *t = RepoPull{}
6997
6998 cr := cbg.NewCborReader(r)
6999
7000 maj, extra, err := cr.ReadHeader()
7001 if err != nil {
7002 return err
7003 }
7004 defer func() {
7005 if err == io.EOF {
7006 err = io.ErrUnexpectedEOF
7007 }
7008 }()
7009
7010 if maj != cbg.MajMap {
7011 return fmt.Errorf("cbor input should be of type map")
7012 }
7013
7014 if extra > cbg.MaxLength {
7015 return fmt.Errorf("RepoPull: map struct too large (%d)", extra)
7016 }
7017
7018 n := extra
7019
7020 nameBuf := make([]byte, 12)
7021 for i := uint64(0); i < n; i++ {
7022 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7023 if err != nil {
7024 return err
7025 }
7026
7027 if !ok {
7028 // Field doesn't exist on this type, so ignore it
7029 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7030 return err
7031 }
7032 continue
7033 }
7034
7035 switch string(nameBuf[:nameLen]) {
7036 // t.Body (string) (string)
7037 case "body":
7038
7039 {
7040 b, err := cr.ReadByte()
7041 if err != nil {
7042 return err
7043 }
7044 if b != cbg.CborNull[0] {
7045 if err := cr.UnreadByte(); err != nil {
7046 return err
7047 }
7048
7049 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7050 if err != nil {
7051 return err
7052 }
7053
7054 t.Body = (*string)(&sval)
7055 }
7056 }
7057 // t.LexiconTypeID (string) (string)
7058 case "$type":
7059
7060 {
7061 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7062 if err != nil {
7063 return err
7064 }
7065
7066 t.LexiconTypeID = string(sval)
7067 }
7068 // t.Patch (string) (string)
7069 case "patch":
7070
7071 {
7072 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7073 if err != nil {
7074 return err
7075 }
7076
7077 t.Patch = string(sval)
7078 }
7079 // t.Title (string) (string)
7080 case "title":
7081
7082 {
7083 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7084 if err != nil {
7085 return err
7086 }
7087
7088 t.Title = string(sval)
7089 }
7090 // t.PullId (int64) (int64)
7091 case "pullId":
7092 {
7093 maj, extra, err := cr.ReadHeader()
7094 if err != nil {
7095 return err
7096 }
7097 var extraI int64
7098 switch maj {
7099 case cbg.MajUnsignedInt:
7100 extraI = int64(extra)
7101 if extraI < 0 {
7102 return fmt.Errorf("int64 positive overflow")
7103 }
7104 case cbg.MajNegativeInt:
7105 extraI = int64(extra)
7106 if extraI < 0 {
7107 return fmt.Errorf("int64 negative overflow")
7108 }
7109 extraI = -1 - extraI
7110 default:
7111 return fmt.Errorf("wrong type for int64 field: %d", maj)
7112 }
7113
7114 t.PullId = int64(extraI)
7115 }
7116 // t.Source (tangled.RepoPull_Source) (struct)
7117 case "source":
7118
7119 {
7120
7121 b, err := cr.ReadByte()
7122 if err != nil {
7123 return err
7124 }
7125 if b != cbg.CborNull[0] {
7126 if err := cr.UnreadByte(); err != nil {
7127 return err
7128 }
7129 t.Source = new(RepoPull_Source)
7130 if err := t.Source.UnmarshalCBOR(cr); err != nil {
7131 return xerrors.Errorf("unmarshaling t.Source pointer: %w", err)
7132 }
7133 }
7134
7135 }
7136 // t.CreatedAt (string) (string)
7137 case "createdAt":
7138
7139 {
7140 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7141 if err != nil {
7142 return err
7143 }
7144
7145 t.CreatedAt = string(sval)
7146 }
7147 // t.TargetRepo (string) (string)
7148 case "targetRepo":
7149
7150 {
7151 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7152 if err != nil {
7153 return err
7154 }
7155
7156 t.TargetRepo = string(sval)
7157 }
7158 // t.TargetBranch (string) (string)
7159 case "targetBranch":
7160
7161 {
7162 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7163 if err != nil {
7164 return err
7165 }
7166
7167 t.TargetBranch = string(sval)
7168 }
7169
7170 default:
7171 // Field doesn't exist on this type, so ignore it
7172 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7173 return err
7174 }
7175 }
7176 }
7177
7178 return nil
7179}
7180func (t *Repo) MarshalCBOR(w io.Writer) error {
7181 if t == nil {
7182 _, err := w.Write(cbg.CborNull)
7183 return err
7184 }
7185
7186 cw := cbg.NewCborWriter(w)
7187 fieldCount := 8
7188
7189 if t.Description == nil {
7190 fieldCount--
7191 }
7192
7193 if t.Source == nil {
7194 fieldCount--
7195 }
7196
7197 if t.Spindle == nil {
7198 fieldCount--
7199 }
7200
7201 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7202 return err
7203 }
7204
7205 // t.Knot (string) (string)
7206 if len("knot") > 1000000 {
7207 return xerrors.Errorf("Value in field \"knot\" was too long")
7208 }
7209
7210 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
7211 return err
7212 }
7213 if _, err := cw.WriteString(string("knot")); err != nil {
7214 return err
7215 }
7216
7217 if len(t.Knot) > 1000000 {
7218 return xerrors.Errorf("Value in field t.Knot was too long")
7219 }
7220
7221 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
7222 return err
7223 }
7224 if _, err := cw.WriteString(string(t.Knot)); err != nil {
7225 return err
7226 }
7227
7228 // t.Name (string) (string)
7229 if len("name") > 1000000 {
7230 return xerrors.Errorf("Value in field \"name\" was too long")
7231 }
7232
7233 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
7234 return err
7235 }
7236 if _, err := cw.WriteString(string("name")); err != nil {
7237 return err
7238 }
7239
7240 if len(t.Name) > 1000000 {
7241 return xerrors.Errorf("Value in field t.Name was too long")
7242 }
7243
7244 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
7245 return err
7246 }
7247 if _, err := cw.WriteString(string(t.Name)); err != nil {
7248 return err
7249 }
7250
7251 // t.LexiconTypeID (string) (string)
7252 if len("$type") > 1000000 {
7253 return xerrors.Errorf("Value in field \"$type\" was too long")
7254 }
7255
7256 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7257 return err
7258 }
7259 if _, err := cw.WriteString(string("$type")); err != nil {
7260 return err
7261 }
7262
7263 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil {
7264 return err
7265 }
7266 if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil {
7267 return err
7268 }
7269
7270 // t.Owner (string) (string)
7271 if len("owner") > 1000000 {
7272 return xerrors.Errorf("Value in field \"owner\" was too long")
7273 }
7274
7275 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
7276 return err
7277 }
7278 if _, err := cw.WriteString(string("owner")); err != nil {
7279 return err
7280 }
7281
7282 if len(t.Owner) > 1000000 {
7283 return xerrors.Errorf("Value in field t.Owner was too long")
7284 }
7285
7286 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {
7287 return err
7288 }
7289 if _, err := cw.WriteString(string(t.Owner)); err != nil {
7290 return err
7291 }
7292
7293 // t.Source (string) (string)
7294 if t.Source != nil {
7295
7296 if len("source") > 1000000 {
7297 return xerrors.Errorf("Value in field \"source\" was too long")
7298 }
7299
7300 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
7301 return err
7302 }
7303 if _, err := cw.WriteString(string("source")); err != nil {
7304 return err
7305 }
7306
7307 if t.Source == nil {
7308 if _, err := cw.Write(cbg.CborNull); err != nil {
7309 return err
7310 }
7311 } else {
7312 if len(*t.Source) > 1000000 {
7313 return xerrors.Errorf("Value in field t.Source was too long")
7314 }
7315
7316 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil {
7317 return err
7318 }
7319 if _, err := cw.WriteString(string(*t.Source)); err != nil {
7320 return err
7321 }
7322 }
7323 }
7324
7325 // t.Spindle (string) (string)
7326 if t.Spindle != nil {
7327
7328 if len("spindle") > 1000000 {
7329 return xerrors.Errorf("Value in field \"spindle\" was too long")
7330 }
7331
7332 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("spindle"))); err != nil {
7333 return err
7334 }
7335 if _, err := cw.WriteString(string("spindle")); err != nil {
7336 return err
7337 }
7338
7339 if t.Spindle == nil {
7340 if _, err := cw.Write(cbg.CborNull); err != nil {
7341 return err
7342 }
7343 } else {
7344 if len(*t.Spindle) > 1000000 {
7345 return xerrors.Errorf("Value in field t.Spindle was too long")
7346 }
7347
7348 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Spindle))); err != nil {
7349 return err
7350 }
7351 if _, err := cw.WriteString(string(*t.Spindle)); err != nil {
7352 return err
7353 }
7354 }
7355 }
7356
7357 // t.CreatedAt (string) (string)
7358 if len("createdAt") > 1000000 {
7359 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7360 }
7361
7362 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7363 return err
7364 }
7365 if _, err := cw.WriteString(string("createdAt")); err != nil {
7366 return err
7367 }
7368
7369 if len(t.CreatedAt) > 1000000 {
7370 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7371 }
7372
7373 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7374 return err
7375 }
7376 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7377 return err
7378 }
7379
7380 // t.Description (string) (string)
7381 if t.Description != nil {
7382
7383 if len("description") > 1000000 {
7384 return xerrors.Errorf("Value in field \"description\" was too long")
7385 }
7386
7387 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
7388 return err
7389 }
7390 if _, err := cw.WriteString(string("description")); err != nil {
7391 return err
7392 }
7393
7394 if t.Description == nil {
7395 if _, err := cw.Write(cbg.CborNull); err != nil {
7396 return err
7397 }
7398 } else {
7399 if len(*t.Description) > 1000000 {
7400 return xerrors.Errorf("Value in field t.Description was too long")
7401 }
7402
7403 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
7404 return err
7405 }
7406 if _, err := cw.WriteString(string(*t.Description)); err != nil {
7407 return err
7408 }
7409 }
7410 }
7411 return nil
7412}
7413
7414func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) {
7415 *t = Repo{}
7416
7417 cr := cbg.NewCborReader(r)
7418
7419 maj, extra, err := cr.ReadHeader()
7420 if err != nil {
7421 return err
7422 }
7423 defer func() {
7424 if err == io.EOF {
7425 err = io.ErrUnexpectedEOF
7426 }
7427 }()
7428
7429 if maj != cbg.MajMap {
7430 return fmt.Errorf("cbor input should be of type map")
7431 }
7432
7433 if extra > cbg.MaxLength {
7434 return fmt.Errorf("Repo: map struct too large (%d)", extra)
7435 }
7436
7437 n := extra
7438
7439 nameBuf := make([]byte, 11)
7440 for i := uint64(0); i < n; i++ {
7441 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7442 if err != nil {
7443 return err
7444 }
7445
7446 if !ok {
7447 // Field doesn't exist on this type, so ignore it
7448 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7449 return err
7450 }
7451 continue
7452 }
7453
7454 switch string(nameBuf[:nameLen]) {
7455 // t.Knot (string) (string)
7456 case "knot":
7457
7458 {
7459 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7460 if err != nil {
7461 return err
7462 }
7463
7464 t.Knot = string(sval)
7465 }
7466 // t.Name (string) (string)
7467 case "name":
7468
7469 {
7470 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7471 if err != nil {
7472 return err
7473 }
7474
7475 t.Name = string(sval)
7476 }
7477 // t.LexiconTypeID (string) (string)
7478 case "$type":
7479
7480 {
7481 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7482 if err != nil {
7483 return err
7484 }
7485
7486 t.LexiconTypeID = string(sval)
7487 }
7488 // t.Owner (string) (string)
7489 case "owner":
7490
7491 {
7492 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7493 if err != nil {
7494 return err
7495 }
7496
7497 t.Owner = string(sval)
7498 }
7499 // t.Source (string) (string)
7500 case "source":
7501
7502 {
7503 b, err := cr.ReadByte()
7504 if err != nil {
7505 return err
7506 }
7507 if b != cbg.CborNull[0] {
7508 if err := cr.UnreadByte(); err != nil {
7509 return err
7510 }
7511
7512 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7513 if err != nil {
7514 return err
7515 }
7516
7517 t.Source = (*string)(&sval)
7518 }
7519 }
7520 // t.Spindle (string) (string)
7521 case "spindle":
7522
7523 {
7524 b, err := cr.ReadByte()
7525 if err != nil {
7526 return err
7527 }
7528 if b != cbg.CborNull[0] {
7529 if err := cr.UnreadByte(); err != nil {
7530 return err
7531 }
7532
7533 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7534 if err != nil {
7535 return err
7536 }
7537
7538 t.Spindle = (*string)(&sval)
7539 }
7540 }
7541 // t.CreatedAt (string) (string)
7542 case "createdAt":
7543
7544 {
7545 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7546 if err != nil {
7547 return err
7548 }
7549
7550 t.CreatedAt = string(sval)
7551 }
7552 // t.Description (string) (string)
7553 case "description":
7554
7555 {
7556 b, err := cr.ReadByte()
7557 if err != nil {
7558 return err
7559 }
7560 if b != cbg.CborNull[0] {
7561 if err := cr.UnreadByte(); err != nil {
7562 return err
7563 }
7564
7565 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7566 if err != nil {
7567 return err
7568 }
7569
7570 t.Description = (*string)(&sval)
7571 }
7572 }
7573
7574 default:
7575 // Field doesn't exist on this type, so ignore it
7576 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7577 return err
7578 }
7579 }
7580 }
7581
7582 return nil
7583}
7584func (t *SpindleMember) MarshalCBOR(w io.Writer) error {
7585 if t == nil {
7586 _, err := w.Write(cbg.CborNull)
7587 return err
7588 }
7589
7590 cw := cbg.NewCborWriter(w)
7591
7592 if _, err := cw.Write([]byte{164}); err != nil {
7593 return err
7594 }
7595
7596 // t.LexiconTypeID (string) (string)
7597 if len("$type") > 1000000 {
7598 return xerrors.Errorf("Value in field \"$type\" was too long")
7599 }
7600
7601 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7602 return err
7603 }
7604 if _, err := cw.WriteString(string("$type")); err != nil {
7605 return err
7606 }
7607
7608 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle.member"))); err != nil {
7609 return err
7610 }
7611 if _, err := cw.WriteString(string("sh.tangled.spindle.member")); err != nil {
7612 return err
7613 }
7614
7615 // t.Subject (string) (string)
7616 if len("subject") > 1000000 {
7617 return xerrors.Errorf("Value in field \"subject\" was too long")
7618 }
7619
7620 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
7621 return err
7622 }
7623 if _, err := cw.WriteString(string("subject")); err != nil {
7624 return err
7625 }
7626
7627 if len(t.Subject) > 1000000 {
7628 return xerrors.Errorf("Value in field t.Subject was too long")
7629 }
7630
7631 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
7632 return err
7633 }
7634 if _, err := cw.WriteString(string(t.Subject)); err != nil {
7635 return err
7636 }
7637
7638 // t.Instance (string) (string)
7639 if len("instance") > 1000000 {
7640 return xerrors.Errorf("Value in field \"instance\" was too long")
7641 }
7642
7643 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("instance"))); err != nil {
7644 return err
7645 }
7646 if _, err := cw.WriteString(string("instance")); err != nil {
7647 return err
7648 }
7649
7650 if len(t.Instance) > 1000000 {
7651 return xerrors.Errorf("Value in field t.Instance was too long")
7652 }
7653
7654 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Instance))); err != nil {
7655 return err
7656 }
7657 if _, err := cw.WriteString(string(t.Instance)); err != nil {
7658 return err
7659 }
7660
7661 // t.CreatedAt (string) (string)
7662 if len("createdAt") > 1000000 {
7663 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7664 }
7665
7666 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7667 return err
7668 }
7669 if _, err := cw.WriteString(string("createdAt")); err != nil {
7670 return err
7671 }
7672
7673 if len(t.CreatedAt) > 1000000 {
7674 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7675 }
7676
7677 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7678 return err
7679 }
7680 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7681 return err
7682 }
7683 return nil
7684}
7685
7686func (t *SpindleMember) UnmarshalCBOR(r io.Reader) (err error) {
7687 *t = SpindleMember{}
7688
7689 cr := cbg.NewCborReader(r)
7690
7691 maj, extra, err := cr.ReadHeader()
7692 if err != nil {
7693 return err
7694 }
7695 defer func() {
7696 if err == io.EOF {
7697 err = io.ErrUnexpectedEOF
7698 }
7699 }()
7700
7701 if maj != cbg.MajMap {
7702 return fmt.Errorf("cbor input should be of type map")
7703 }
7704
7705 if extra > cbg.MaxLength {
7706 return fmt.Errorf("SpindleMember: map struct too large (%d)", extra)
7707 }
7708
7709 n := extra
7710
7711 nameBuf := make([]byte, 9)
7712 for i := uint64(0); i < n; i++ {
7713 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7714 if err != nil {
7715 return err
7716 }
7717
7718 if !ok {
7719 // Field doesn't exist on this type, so ignore it
7720 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7721 return err
7722 }
7723 continue
7724 }
7725
7726 switch string(nameBuf[:nameLen]) {
7727 // t.LexiconTypeID (string) (string)
7728 case "$type":
7729
7730 {
7731 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7732 if err != nil {
7733 return err
7734 }
7735
7736 t.LexiconTypeID = string(sval)
7737 }
7738 // t.Subject (string) (string)
7739 case "subject":
7740
7741 {
7742 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7743 if err != nil {
7744 return err
7745 }
7746
7747 t.Subject = string(sval)
7748 }
7749 // t.Instance (string) (string)
7750 case "instance":
7751
7752 {
7753 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7754 if err != nil {
7755 return err
7756 }
7757
7758 t.Instance = string(sval)
7759 }
7760 // t.CreatedAt (string) (string)
7761 case "createdAt":
7762
7763 {
7764 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7765 if err != nil {
7766 return err
7767 }
7768
7769 t.CreatedAt = string(sval)
7770 }
7771
7772 default:
7773 // Field doesn't exist on this type, so ignore it
7774 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7775 return err
7776 }
7777 }
7778 }
7779
7780 return nil
7781}