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