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