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}
3017
3018func (t *Pipeline_Step_Environment_Elem) MarshalCBOR(w io.Writer) error {
3019 if t == nil {
3020 _, err := w.Write(cbg.CborNull)
3021 return err
3022 }
3023
3024 cw := cbg.NewCborWriter(w)
3025
3026 if _, err := cw.Write([]byte{162}); err != nil {
3027 return err
3028 }
3029
3030 // t.Key (string) (string)
3031 if len("key") > 1000000 {
3032 return xerrors.Errorf("Value in field \"key\" was too long")
3033 }
3034
3035 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
3036 return err
3037 }
3038 if _, err := cw.WriteString(string("key")); err != nil {
3039 return err
3040 }
3041
3042 if len(t.Key) > 1000000 {
3043 return xerrors.Errorf("Value in field t.Key was too long")
3044 }
3045
3046 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
3047 return err
3048 }
3049 if _, err := cw.WriteString(string(t.Key)); err != nil {
3050 return err
3051 }
3052
3053 // t.Value (string) (string)
3054 if len("value") > 1000000 {
3055 return xerrors.Errorf("Value in field \"value\" was too long")
3056 }
3057
3058 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
3059 return err
3060 }
3061 if _, err := cw.WriteString(string("value")); err != nil {
3062 return err
3063 }
3064
3065 if len(t.Value) > 1000000 {
3066 return xerrors.Errorf("Value in field t.Value was too long")
3067 }
3068
3069 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
3070 return err
3071 }
3072 if _, err := cw.WriteString(string(t.Value)); err != nil {
3073 return err
3074 }
3075 return nil
3076}
3077
3078func (t *Pipeline_Step_Environment_Elem) UnmarshalCBOR(r io.Reader) (err error) {
3079 *t = Pipeline_Step_Environment_Elem{}
3080
3081 cr := cbg.NewCborReader(r)
3082
3083 maj, extra, err := cr.ReadHeader()
3084 if err != nil {
3085 return err
3086 }
3087 defer func() {
3088 if err == io.EOF {
3089 err = io.ErrUnexpectedEOF
3090 }
3091 }()
3092
3093 if maj != cbg.MajMap {
3094 return fmt.Errorf("cbor input should be of type map")
3095 }
3096
3097 if extra > cbg.MaxLength {
3098 return fmt.Errorf("Pipeline_Step_Environment_Elem: map struct too large (%d)", extra)
3099 }
3100
3101 n := extra
3102
3103 nameBuf := make([]byte, 5)
3104 for i := uint64(0); i < n; i++ {
3105 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3106 if err != nil {
3107 return err
3108 }
3109
3110 if !ok {
3111 // Field doesn't exist on this type, so ignore it
3112 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3113 return err
3114 }
3115 continue
3116 }
3117
3118 switch string(nameBuf[:nameLen]) {
3119 // t.Key (string) (string)
3120 case "key":
3121
3122 {
3123 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3124 if err != nil {
3125 return err
3126 }
3127
3128 t.Key = string(sval)
3129 }
3130 // t.Value (string) (string)
3131 case "value":
3132
3133 {
3134 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3135 if err != nil {
3136 return err
3137 }
3138
3139 t.Value = string(sval)
3140 }
3141
3142 default:
3143 // Field doesn't exist on this type, so ignore it
3144 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3145 return err
3146 }
3147 }
3148 }
3149
3150 return nil
3151}
3152func (t *PipelineStatus) MarshalCBOR(w io.Writer) error {
3153 if t == nil {
3154 _, err := w.Write(cbg.CborNull)
3155 return err
3156 }
3157
3158 cw := cbg.NewCborWriter(w)
3159 fieldCount := 7
3160
3161 if t.Error == nil {
3162 fieldCount--
3163 }
3164
3165 if t.ExitCode == nil {
3166 fieldCount--
3167 }
3168
3169 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3170 return err
3171 }
3172
3173 // t.LexiconTypeID (string) (string)
3174 if len("$type") > 1000000 {
3175 return xerrors.Errorf("Value in field \"$type\" was too long")
3176 }
3177
3178 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3179 return err
3180 }
3181 if _, err := cw.WriteString(string("$type")); err != nil {
3182 return err
3183 }
3184
3185 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline.status"))); err != nil {
3186 return err
3187 }
3188 if _, err := cw.WriteString(string("sh.tangled.pipeline.status")); err != nil {
3189 return err
3190 }
3191
3192 // t.Error (string) (string)
3193 if t.Error != nil {
3194
3195 if len("error") > 1000000 {
3196 return xerrors.Errorf("Value in field \"error\" was too long")
3197 }
3198
3199 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("error"))); err != nil {
3200 return err
3201 }
3202 if _, err := cw.WriteString(string("error")); err != nil {
3203 return err
3204 }
3205
3206 if t.Error == nil {
3207 if _, err := cw.Write(cbg.CborNull); err != nil {
3208 return err
3209 }
3210 } else {
3211 if len(*t.Error) > 1000000 {
3212 return xerrors.Errorf("Value in field t.Error was too long")
3213 }
3214
3215 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Error))); err != nil {
3216 return err
3217 }
3218 if _, err := cw.WriteString(string(*t.Error)); err != nil {
3219 return err
3220 }
3221 }
3222 }
3223
3224 // t.Status (string) (string)
3225 if len("status") > 1000000 {
3226 return xerrors.Errorf("Value in field \"status\" was too long")
3227 }
3228
3229 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
3230 return err
3231 }
3232 if _, err := cw.WriteString(string("status")); err != nil {
3233 return err
3234 }
3235
3236 if len(t.Status) > 1000000 {
3237 return xerrors.Errorf("Value in field t.Status was too long")
3238 }
3239
3240 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
3241 return err
3242 }
3243 if _, err := cw.WriteString(string(t.Status)); err != nil {
3244 return err
3245 }
3246
3247 // t.ExitCode (int64) (int64)
3248 if t.ExitCode != nil {
3249
3250 if len("exitCode") > 1000000 {
3251 return xerrors.Errorf("Value in field \"exitCode\" was too long")
3252 }
3253
3254 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("exitCode"))); err != nil {
3255 return err
3256 }
3257 if _, err := cw.WriteString(string("exitCode")); err != nil {
3258 return err
3259 }
3260
3261 if t.ExitCode == nil {
3262 if _, err := cw.Write(cbg.CborNull); err != nil {
3263 return err
3264 }
3265 } else {
3266 if *t.ExitCode >= 0 {
3267 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.ExitCode)); err != nil {
3268 return err
3269 }
3270 } else {
3271 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.ExitCode-1)); err != nil {
3272 return err
3273 }
3274 }
3275 }
3276
3277 }
3278
3279 // t.Pipeline (string) (string)
3280 if len("pipeline") > 1000000 {
3281 return xerrors.Errorf("Value in field \"pipeline\" was too long")
3282 }
3283
3284 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pipeline"))); err != nil {
3285 return err
3286 }
3287 if _, err := cw.WriteString(string("pipeline")); err != nil {
3288 return err
3289 }
3290
3291 if len(t.Pipeline) > 1000000 {
3292 return xerrors.Errorf("Value in field t.Pipeline was too long")
3293 }
3294
3295 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pipeline))); err != nil {
3296 return err
3297 }
3298 if _, err := cw.WriteString(string(t.Pipeline)); err != nil {
3299 return err
3300 }
3301
3302 // t.Workflow (string) (string)
3303 if len("workflow") > 1000000 {
3304 return xerrors.Errorf("Value in field \"workflow\" was too long")
3305 }
3306
3307 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil {
3308 return err
3309 }
3310 if _, err := cw.WriteString(string("workflow")); err != nil {
3311 return err
3312 }
3313
3314 if len(t.Workflow) > 1000000 {
3315 return xerrors.Errorf("Value in field t.Workflow was too long")
3316 }
3317
3318 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil {
3319 return err
3320 }
3321 if _, err := cw.WriteString(string(t.Workflow)); err != nil {
3322 return err
3323 }
3324
3325 // t.CreatedAt (string) (string)
3326 if len("createdAt") > 1000000 {
3327 return xerrors.Errorf("Value in field \"createdAt\" was too long")
3328 }
3329
3330 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
3331 return err
3332 }
3333 if _, err := cw.WriteString(string("createdAt")); err != nil {
3334 return err
3335 }
3336
3337 if len(t.CreatedAt) > 1000000 {
3338 return xerrors.Errorf("Value in field t.CreatedAt was too long")
3339 }
3340
3341 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
3342 return err
3343 }
3344 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
3345 return err
3346 }
3347 return nil
3348}
3349
3350func (t *PipelineStatus) UnmarshalCBOR(r io.Reader) (err error) {
3351 *t = PipelineStatus{}
3352
3353 cr := cbg.NewCborReader(r)
3354
3355 maj, extra, err := cr.ReadHeader()
3356 if err != nil {
3357 return err
3358 }
3359 defer func() {
3360 if err == io.EOF {
3361 err = io.ErrUnexpectedEOF
3362 }
3363 }()
3364
3365 if maj != cbg.MajMap {
3366 return fmt.Errorf("cbor input should be of type map")
3367 }
3368
3369 if extra > cbg.MaxLength {
3370 return fmt.Errorf("PipelineStatus: map struct too large (%d)", extra)
3371 }
3372
3373 n := extra
3374
3375 nameBuf := make([]byte, 9)
3376 for i := uint64(0); i < n; i++ {
3377 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3378 if err != nil {
3379 return err
3380 }
3381
3382 if !ok {
3383 // Field doesn't exist on this type, so ignore it
3384 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3385 return err
3386 }
3387 continue
3388 }
3389
3390 switch string(nameBuf[:nameLen]) {
3391 // t.LexiconTypeID (string) (string)
3392 case "$type":
3393
3394 {
3395 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3396 if err != nil {
3397 return err
3398 }
3399
3400 t.LexiconTypeID = string(sval)
3401 }
3402 // t.Error (string) (string)
3403 case "error":
3404
3405 {
3406 b, err := cr.ReadByte()
3407 if err != nil {
3408 return err
3409 }
3410 if b != cbg.CborNull[0] {
3411 if err := cr.UnreadByte(); err != nil {
3412 return err
3413 }
3414
3415 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3416 if err != nil {
3417 return err
3418 }
3419
3420 t.Error = (*string)(&sval)
3421 }
3422 }
3423 // t.Status (string) (string)
3424 case "status":
3425
3426 {
3427 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3428 if err != nil {
3429 return err
3430 }
3431
3432 t.Status = string(sval)
3433 }
3434 // t.ExitCode (int64) (int64)
3435 case "exitCode":
3436 {
3437
3438 b, err := cr.ReadByte()
3439 if err != nil {
3440 return err
3441 }
3442 if b != cbg.CborNull[0] {
3443 if err := cr.UnreadByte(); err != nil {
3444 return err
3445 }
3446 maj, extra, err := cr.ReadHeader()
3447 if err != nil {
3448 return err
3449 }
3450 var extraI int64
3451 switch maj {
3452 case cbg.MajUnsignedInt:
3453 extraI = int64(extra)
3454 if extraI < 0 {
3455 return fmt.Errorf("int64 positive overflow")
3456 }
3457 case cbg.MajNegativeInt:
3458 extraI = int64(extra)
3459 if extraI < 0 {
3460 return fmt.Errorf("int64 negative overflow")
3461 }
3462 extraI = -1 - extraI
3463 default:
3464 return fmt.Errorf("wrong type for int64 field: %d", maj)
3465 }
3466
3467 t.ExitCode = (*int64)(&extraI)
3468 }
3469 }
3470 // t.Pipeline (string) (string)
3471 case "pipeline":
3472
3473 {
3474 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3475 if err != nil {
3476 return err
3477 }
3478
3479 t.Pipeline = string(sval)
3480 }
3481 // t.Workflow (string) (string)
3482 case "workflow":
3483
3484 {
3485 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3486 if err != nil {
3487 return err
3488 }
3489
3490 t.Workflow = string(sval)
3491 }
3492 // t.CreatedAt (string) (string)
3493 case "createdAt":
3494
3495 {
3496 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3497 if err != nil {
3498 return err
3499 }
3500
3501 t.CreatedAt = string(sval)
3502 }
3503
3504 default:
3505 // Field doesn't exist on this type, so ignore it
3506 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3507 return err
3508 }
3509 }
3510 }
3511
3512 return nil
3513}
3514
3515func (t *Pipeline_Step) MarshalCBOR(w io.Writer) error {
3516 if t == nil {
3517 _, err := w.Write(cbg.CborNull)
3518 return err
3519 }
3520
3521 cw := cbg.NewCborWriter(w)
3522 fieldCount := 3
3523
3524 if t.Environment == nil {
3525 fieldCount--
3526 }
3527
3528 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3529 return err
3530 }
3531
3532 // t.Name (string) (string)
3533 if len("name") > 1000000 {
3534 return xerrors.Errorf("Value in field \"name\" was too long")
3535 }
3536
3537 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
3538 return err
3539 }
3540 if _, err := cw.WriteString(string("name")); err != nil {
3541 return err
3542 }
3543
3544 if len(t.Name) > 1000000 {
3545 return xerrors.Errorf("Value in field t.Name was too long")
3546 }
3547
3548 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
3549 return err
3550 }
3551 if _, err := cw.WriteString(string(t.Name)); err != nil {
3552 return err
3553 }
3554
3555 // t.Command (string) (string)
3556 if len("command") > 1000000 {
3557 return xerrors.Errorf("Value in field \"command\" was too long")
3558 }
3559
3560 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("command"))); err != nil {
3561 return err
3562 }
3563 if _, err := cw.WriteString(string("command")); err != nil {
3564 return err
3565 }
3566
3567 if len(t.Command) > 1000000 {
3568 return xerrors.Errorf("Value in field t.Command was too long")
3569 }
3570
3571 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Command))); err != nil {
3572 return err
3573 }
3574 if _, err := cw.WriteString(string(t.Command)); err != nil {
3575 return err
3576 }
3577
3578 // t.Environment ([]*tangled.Pipeline_Step_Environment_Elem) (slice)
3579 if t.Environment != nil {
3580
3581 if len("environment") > 1000000 {
3582 return xerrors.Errorf("Value in field \"environment\" was too long")
3583 }
3584
3585 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("environment"))); err != nil {
3586 return err
3587 }
3588 if _, err := cw.WriteString(string("environment")); err != nil {
3589 return err
3590 }
3591
3592 if len(t.Environment) > 8192 {
3593 return xerrors.Errorf("Slice value in field t.Environment was too long")
3594 }
3595
3596 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Environment))); err != nil {
3597 return err
3598 }
3599 for _, v := range t.Environment {
3600 if err := v.MarshalCBOR(cw); err != nil {
3601 return err
3602 }
3603
3604 }
3605 }
3606 return nil
3607}
3608
3609func (t *Pipeline_Step) UnmarshalCBOR(r io.Reader) (err error) {
3610 *t = Pipeline_Step{}
3611
3612 cr := cbg.NewCborReader(r)
3613
3614 maj, extra, err := cr.ReadHeader()
3615 if err != nil {
3616 return err
3617 }
3618 defer func() {
3619 if err == io.EOF {
3620 err = io.ErrUnexpectedEOF
3621 }
3622 }()
3623
3624 if maj != cbg.MajMap {
3625 return fmt.Errorf("cbor input should be of type map")
3626 }
3627
3628 if extra > cbg.MaxLength {
3629 return fmt.Errorf("Pipeline_Step: map struct too large (%d)", extra)
3630 }
3631
3632 n := extra
3633
3634 nameBuf := make([]byte, 11)
3635 for i := uint64(0); i < n; i++ {
3636 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3637 if err != nil {
3638 return err
3639 }
3640
3641 if !ok {
3642 // Field doesn't exist on this type, so ignore it
3643 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3644 return err
3645 }
3646 continue
3647 }
3648
3649 switch string(nameBuf[:nameLen]) {
3650 // t.Name (string) (string)
3651 case "name":
3652
3653 {
3654 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3655 if err != nil {
3656 return err
3657 }
3658
3659 t.Name = string(sval)
3660 }
3661 // t.Command (string) (string)
3662 case "command":
3663
3664 {
3665 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3666 if err != nil {
3667 return err
3668 }
3669
3670 t.Command = string(sval)
3671 }
3672 // t.Environment ([]*tangled.Pipeline_Step_Environment_Elem) (slice)
3673 case "environment":
3674
3675 maj, extra, err = cr.ReadHeader()
3676 if err != nil {
3677 return err
3678 }
3679
3680 if extra > 8192 {
3681 return fmt.Errorf("t.Environment: array too large (%d)", extra)
3682 }
3683
3684 if maj != cbg.MajArray {
3685 return fmt.Errorf("expected cbor array")
3686 }
3687
3688 if extra > 0 {
3689 t.Environment = make([]*Pipeline_Step_Environment_Elem, extra)
3690 }
3691
3692 for i := 0; i < int(extra); i++ {
3693 {
3694 var maj byte
3695 var extra uint64
3696 var err error
3697 _ = maj
3698 _ = extra
3699 _ = err
3700
3701 {
3702
3703 b, err := cr.ReadByte()
3704 if err != nil {
3705 return err
3706 }
3707 if b != cbg.CborNull[0] {
3708 if err := cr.UnreadByte(); err != nil {
3709 return err
3710 }
3711 t.Environment[i] = new(Pipeline_Step_Environment_Elem)
3712 if err := t.Environment[i].UnmarshalCBOR(cr); err != nil {
3713 return xerrors.Errorf("unmarshaling t.Environment[i] pointer: %w", err)
3714 }
3715 }
3716
3717 }
3718
3719 }
3720 }
3721
3722 default:
3723 // Field doesn't exist on this type, so ignore it
3724 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3725 return err
3726 }
3727 }
3728 }
3729
3730 return nil
3731}
3732func (t *Pipeline_TriggerMetadata) MarshalCBOR(w io.Writer) error {
3733 if t == nil {
3734 _, err := w.Write(cbg.CborNull)
3735 return err
3736 }
3737
3738 cw := cbg.NewCborWriter(w)
3739 fieldCount := 5
3740
3741 if t.Manual == nil {
3742 fieldCount--
3743 }
3744
3745 if t.PullRequest == nil {
3746 fieldCount--
3747 }
3748
3749 if t.Push == nil {
3750 fieldCount--
3751 }
3752
3753 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3754 return err
3755 }
3756
3757 // t.Kind (string) (string)
3758 if len("kind") > 1000000 {
3759 return xerrors.Errorf("Value in field \"kind\" was too long")
3760 }
3761
3762 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("kind"))); err != nil {
3763 return err
3764 }
3765 if _, err := cw.WriteString(string("kind")); err != nil {
3766 return err
3767 }
3768
3769 if len(t.Kind) > 1000000 {
3770 return xerrors.Errorf("Value in field t.Kind was too long")
3771 }
3772
3773 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Kind))); err != nil {
3774 return err
3775 }
3776 if _, err := cw.WriteString(string(t.Kind)); err != nil {
3777 return err
3778 }
3779
3780 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
3781 if t.Push != nil {
3782
3783 if len("push") > 1000000 {
3784 return xerrors.Errorf("Value in field \"push\" was too long")
3785 }
3786
3787 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("push"))); err != nil {
3788 return err
3789 }
3790 if _, err := cw.WriteString(string("push")); err != nil {
3791 return err
3792 }
3793
3794 if err := t.Push.MarshalCBOR(cw); err != nil {
3795 return err
3796 }
3797 }
3798
3799 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
3800 if len("repo") > 1000000 {
3801 return xerrors.Errorf("Value in field \"repo\" was too long")
3802 }
3803
3804 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
3805 return err
3806 }
3807 if _, err := cw.WriteString(string("repo")); err != nil {
3808 return err
3809 }
3810
3811 if err := t.Repo.MarshalCBOR(cw); err != nil {
3812 return err
3813 }
3814
3815 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
3816 if t.Manual != nil {
3817
3818 if len("manual") > 1000000 {
3819 return xerrors.Errorf("Value in field \"manual\" was too long")
3820 }
3821
3822 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("manual"))); err != nil {
3823 return err
3824 }
3825 if _, err := cw.WriteString(string("manual")); err != nil {
3826 return err
3827 }
3828
3829 if err := t.Manual.MarshalCBOR(cw); err != nil {
3830 return err
3831 }
3832 }
3833
3834 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
3835 if t.PullRequest != nil {
3836
3837 if len("pullRequest") > 1000000 {
3838 return xerrors.Errorf("Value in field \"pullRequest\" was too long")
3839 }
3840
3841 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullRequest"))); err != nil {
3842 return err
3843 }
3844 if _, err := cw.WriteString(string("pullRequest")); err != nil {
3845 return err
3846 }
3847
3848 if err := t.PullRequest.MarshalCBOR(cw); err != nil {
3849 return err
3850 }
3851 }
3852 return nil
3853}
3854
3855func (t *Pipeline_TriggerMetadata) UnmarshalCBOR(r io.Reader) (err error) {
3856 *t = Pipeline_TriggerMetadata{}
3857
3858 cr := cbg.NewCborReader(r)
3859
3860 maj, extra, err := cr.ReadHeader()
3861 if err != nil {
3862 return err
3863 }
3864 defer func() {
3865 if err == io.EOF {
3866 err = io.ErrUnexpectedEOF
3867 }
3868 }()
3869
3870 if maj != cbg.MajMap {
3871 return fmt.Errorf("cbor input should be of type map")
3872 }
3873
3874 if extra > cbg.MaxLength {
3875 return fmt.Errorf("Pipeline_TriggerMetadata: map struct too large (%d)", extra)
3876 }
3877
3878 n := extra
3879
3880 nameBuf := make([]byte, 11)
3881 for i := uint64(0); i < n; i++ {
3882 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3883 if err != nil {
3884 return err
3885 }
3886
3887 if !ok {
3888 // Field doesn't exist on this type, so ignore it
3889 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3890 return err
3891 }
3892 continue
3893 }
3894
3895 switch string(nameBuf[:nameLen]) {
3896 // t.Kind (string) (string)
3897 case "kind":
3898
3899 {
3900 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3901 if err != nil {
3902 return err
3903 }
3904
3905 t.Kind = string(sval)
3906 }
3907 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
3908 case "push":
3909
3910 {
3911
3912 b, err := cr.ReadByte()
3913 if err != nil {
3914 return err
3915 }
3916 if b != cbg.CborNull[0] {
3917 if err := cr.UnreadByte(); err != nil {
3918 return err
3919 }
3920 t.Push = new(Pipeline_PushTriggerData)
3921 if err := t.Push.UnmarshalCBOR(cr); err != nil {
3922 return xerrors.Errorf("unmarshaling t.Push pointer: %w", err)
3923 }
3924 }
3925
3926 }
3927 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
3928 case "repo":
3929
3930 {
3931
3932 b, err := cr.ReadByte()
3933 if err != nil {
3934 return err
3935 }
3936 if b != cbg.CborNull[0] {
3937 if err := cr.UnreadByte(); err != nil {
3938 return err
3939 }
3940 t.Repo = new(Pipeline_TriggerRepo)
3941 if err := t.Repo.UnmarshalCBOR(cr); err != nil {
3942 return xerrors.Errorf("unmarshaling t.Repo pointer: %w", err)
3943 }
3944 }
3945
3946 }
3947 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
3948 case "manual":
3949
3950 {
3951
3952 b, err := cr.ReadByte()
3953 if err != nil {
3954 return err
3955 }
3956 if b != cbg.CborNull[0] {
3957 if err := cr.UnreadByte(); err != nil {
3958 return err
3959 }
3960 t.Manual = new(Pipeline_ManualTriggerData)
3961 if err := t.Manual.UnmarshalCBOR(cr); err != nil {
3962 return xerrors.Errorf("unmarshaling t.Manual pointer: %w", err)
3963 }
3964 }
3965
3966 }
3967 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
3968 case "pullRequest":
3969
3970 {
3971
3972 b, err := cr.ReadByte()
3973 if err != nil {
3974 return err
3975 }
3976 if b != cbg.CborNull[0] {
3977 if err := cr.UnreadByte(); err != nil {
3978 return err
3979 }
3980 t.PullRequest = new(Pipeline_PullRequestTriggerData)
3981 if err := t.PullRequest.UnmarshalCBOR(cr); err != nil {
3982 return xerrors.Errorf("unmarshaling t.PullRequest pointer: %w", err)
3983 }
3984 }
3985
3986 }
3987
3988 default:
3989 // Field doesn't exist on this type, so ignore it
3990 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3991 return err
3992 }
3993 }
3994 }
3995
3996 return nil
3997}
3998func (t *Pipeline_TriggerRepo) MarshalCBOR(w io.Writer) error {
3999 if t == nil {
4000 _, err := w.Write(cbg.CborNull)
4001 return err
4002 }
4003
4004 cw := cbg.NewCborWriter(w)
4005
4006 if _, err := cw.Write([]byte{164}); err != nil {
4007 return err
4008 }
4009
4010 // t.Did (string) (string)
4011 if len("did") > 1000000 {
4012 return xerrors.Errorf("Value in field \"did\" was too long")
4013 }
4014
4015 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil {
4016 return err
4017 }
4018 if _, err := cw.WriteString(string("did")); err != nil {
4019 return err
4020 }
4021
4022 if len(t.Did) > 1000000 {
4023 return xerrors.Errorf("Value in field t.Did was too long")
4024 }
4025
4026 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil {
4027 return err
4028 }
4029 if _, err := cw.WriteString(string(t.Did)); err != nil {
4030 return err
4031 }
4032
4033 // t.Knot (string) (string)
4034 if len("knot") > 1000000 {
4035 return xerrors.Errorf("Value in field \"knot\" was too long")
4036 }
4037
4038 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
4039 return err
4040 }
4041 if _, err := cw.WriteString(string("knot")); err != nil {
4042 return err
4043 }
4044
4045 if len(t.Knot) > 1000000 {
4046 return xerrors.Errorf("Value in field t.Knot was too long")
4047 }
4048
4049 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
4050 return err
4051 }
4052 if _, err := cw.WriteString(string(t.Knot)); err != nil {
4053 return err
4054 }
4055
4056 // t.Repo (string) (string)
4057 if len("repo") > 1000000 {
4058 return xerrors.Errorf("Value in field \"repo\" was too long")
4059 }
4060
4061 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
4062 return err
4063 }
4064 if _, err := cw.WriteString(string("repo")); err != nil {
4065 return err
4066 }
4067
4068 if len(t.Repo) > 1000000 {
4069 return xerrors.Errorf("Value in field t.Repo was too long")
4070 }
4071
4072 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
4073 return err
4074 }
4075 if _, err := cw.WriteString(string(t.Repo)); err != nil {
4076 return err
4077 }
4078
4079 // t.DefaultBranch (string) (string)
4080 if len("defaultBranch") > 1000000 {
4081 return xerrors.Errorf("Value in field \"defaultBranch\" was too long")
4082 }
4083
4084 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("defaultBranch"))); err != nil {
4085 return err
4086 }
4087 if _, err := cw.WriteString(string("defaultBranch")); err != nil {
4088 return err
4089 }
4090
4091 if len(t.DefaultBranch) > 1000000 {
4092 return xerrors.Errorf("Value in field t.DefaultBranch was too long")
4093 }
4094
4095 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.DefaultBranch))); err != nil {
4096 return err
4097 }
4098 if _, err := cw.WriteString(string(t.DefaultBranch)); err != nil {
4099 return err
4100 }
4101 return nil
4102}
4103
4104func (t *Pipeline_TriggerRepo) UnmarshalCBOR(r io.Reader) (err error) {
4105 *t = Pipeline_TriggerRepo{}
4106
4107 cr := cbg.NewCborReader(r)
4108
4109 maj, extra, err := cr.ReadHeader()
4110 if err != nil {
4111 return err
4112 }
4113 defer func() {
4114 if err == io.EOF {
4115 err = io.ErrUnexpectedEOF
4116 }
4117 }()
4118
4119 if maj != cbg.MajMap {
4120 return fmt.Errorf("cbor input should be of type map")
4121 }
4122
4123 if extra > cbg.MaxLength {
4124 return fmt.Errorf("Pipeline_TriggerRepo: map struct too large (%d)", extra)
4125 }
4126
4127 n := extra
4128
4129 nameBuf := make([]byte, 13)
4130 for i := uint64(0); i < n; i++ {
4131 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4132 if err != nil {
4133 return err
4134 }
4135
4136 if !ok {
4137 // Field doesn't exist on this type, so ignore it
4138 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4139 return err
4140 }
4141 continue
4142 }
4143
4144 switch string(nameBuf[:nameLen]) {
4145 // t.Did (string) (string)
4146 case "did":
4147
4148 {
4149 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4150 if err != nil {
4151 return err
4152 }
4153
4154 t.Did = string(sval)
4155 }
4156 // t.Knot (string) (string)
4157 case "knot":
4158
4159 {
4160 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4161 if err != nil {
4162 return err
4163 }
4164
4165 t.Knot = string(sval)
4166 }
4167 // t.Repo (string) (string)
4168 case "repo":
4169
4170 {
4171 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4172 if err != nil {
4173 return err
4174 }
4175
4176 t.Repo = string(sval)
4177 }
4178 // t.DefaultBranch (string) (string)
4179 case "defaultBranch":
4180
4181 {
4182 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4183 if err != nil {
4184 return err
4185 }
4186
4187 t.DefaultBranch = string(sval)
4188 }
4189
4190 default:
4191 // Field doesn't exist on this type, so ignore it
4192 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4193 return err
4194 }
4195 }
4196 }
4197
4198 return nil
4199}
4200func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error {
4201 if t == nil {
4202 _, err := w.Write(cbg.CborNull)
4203 return err
4204 }
4205
4206 cw := cbg.NewCborWriter(w)
4207
4208 if _, err := cw.Write([]byte{165}); err != nil {
4209 return err
4210 }
4211
4212 // t.Name (string) (string)
4213 if len("name") > 1000000 {
4214 return xerrors.Errorf("Value in field \"name\" was too long")
4215 }
4216
4217 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
4218 return err
4219 }
4220 if _, err := cw.WriteString(string("name")); err != nil {
4221 return err
4222 }
4223
4224 if len(t.Name) > 1000000 {
4225 return xerrors.Errorf("Value in field t.Name was too long")
4226 }
4227
4228 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
4229 return err
4230 }
4231 if _, err := cw.WriteString(string(t.Name)); err != nil {
4232 return err
4233 }
4234
4235 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
4236 if len("clone") > 1000000 {
4237 return xerrors.Errorf("Value in field \"clone\" was too long")
4238 }
4239
4240 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil {
4241 return err
4242 }
4243 if _, err := cw.WriteString(string("clone")); err != nil {
4244 return err
4245 }
4246
4247 if err := t.Clone.MarshalCBOR(cw); err != nil {
4248 return err
4249 }
4250
4251 // t.Steps ([]*tangled.Pipeline_Step) (slice)
4252 if len("steps") > 1000000 {
4253 return xerrors.Errorf("Value in field \"steps\" was too long")
4254 }
4255
4256 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("steps"))); err != nil {
4257 return err
4258 }
4259 if _, err := cw.WriteString(string("steps")); err != nil {
4260 return err
4261 }
4262
4263 if len(t.Steps) > 8192 {
4264 return xerrors.Errorf("Slice value in field t.Steps was too long")
4265 }
4266
4267 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Steps))); err != nil {
4268 return err
4269 }
4270 for _, v := range t.Steps {
4271 if err := v.MarshalCBOR(cw); err != nil {
4272 return err
4273 }
4274
4275 }
4276
4277 // t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice)
4278 if len("environment") > 1000000 {
4279 return xerrors.Errorf("Value in field \"environment\" was too long")
4280 }
4281
4282 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("environment"))); err != nil {
4283 return err
4284 }
4285 if _, err := cw.WriteString(string("environment")); err != nil {
4286 return err
4287 }
4288
4289 if len(t.Environment) > 8192 {
4290 return xerrors.Errorf("Slice value in field t.Environment was too long")
4291 }
4292
4293 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Environment))); err != nil {
4294 return err
4295 }
4296 for _, v := range t.Environment {
4297 if err := v.MarshalCBOR(cw); err != nil {
4298 return err
4299 }
4300
4301 }
4302
4303 // t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice)
4304 if len("dependencies") > 1000000 {
4305 return xerrors.Errorf("Value in field \"dependencies\" was too long")
4306 }
4307
4308 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("dependencies"))); err != nil {
4309 return err
4310 }
4311 if _, err := cw.WriteString(string("dependencies")); err != nil {
4312 return err
4313 }
4314
4315 if len(t.Dependencies) > 8192 {
4316 return xerrors.Errorf("Slice value in field t.Dependencies was too long")
4317 }
4318
4319 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Dependencies))); err != nil {
4320 return err
4321 }
4322 for _, v := range t.Dependencies {
4323 if err := v.MarshalCBOR(cw); err != nil {
4324 return err
4325 }
4326
4327 }
4328 return nil
4329}
4330
4331func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) {
4332 *t = Pipeline_Workflow{}
4333
4334 cr := cbg.NewCborReader(r)
4335
4336 maj, extra, err := cr.ReadHeader()
4337 if err != nil {
4338 return err
4339 }
4340 defer func() {
4341 if err == io.EOF {
4342 err = io.ErrUnexpectedEOF
4343 }
4344 }()
4345
4346 if maj != cbg.MajMap {
4347 return fmt.Errorf("cbor input should be of type map")
4348 }
4349
4350 if extra > cbg.MaxLength {
4351 return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra)
4352 }
4353
4354 n := extra
4355
4356 nameBuf := make([]byte, 12)
4357 for i := uint64(0); i < n; i++ {
4358 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4359 if err != nil {
4360 return err
4361 }
4362
4363 if !ok {
4364 // Field doesn't exist on this type, so ignore it
4365 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4366 return err
4367 }
4368 continue
4369 }
4370
4371 switch string(nameBuf[:nameLen]) {
4372 // t.Name (string) (string)
4373 case "name":
4374
4375 {
4376 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4377 if err != nil {
4378 return err
4379 }
4380
4381 t.Name = string(sval)
4382 }
4383 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
4384 case "clone":
4385
4386 {
4387
4388 b, err := cr.ReadByte()
4389 if err != nil {
4390 return err
4391 }
4392 if b != cbg.CborNull[0] {
4393 if err := cr.UnreadByte(); err != nil {
4394 return err
4395 }
4396 t.Clone = new(Pipeline_CloneOpts)
4397 if err := t.Clone.UnmarshalCBOR(cr); err != nil {
4398 return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err)
4399 }
4400 }
4401
4402 }
4403 // t.Steps ([]*tangled.Pipeline_Step) (slice)
4404 case "steps":
4405
4406 maj, extra, err = cr.ReadHeader()
4407 if err != nil {
4408 return err
4409 }
4410
4411 if extra > 8192 {
4412 return fmt.Errorf("t.Steps: array too large (%d)", extra)
4413 }
4414
4415 if maj != cbg.MajArray {
4416 return fmt.Errorf("expected cbor array")
4417 }
4418
4419 if extra > 0 {
4420 t.Steps = make([]*Pipeline_Step, extra)
4421 }
4422
4423 for i := 0; i < int(extra); i++ {
4424 {
4425 var maj byte
4426 var extra uint64
4427 var err error
4428 _ = maj
4429 _ = extra
4430 _ = err
4431
4432 {
4433
4434 b, err := cr.ReadByte()
4435 if err != nil {
4436 return err
4437 }
4438 if b != cbg.CborNull[0] {
4439 if err := cr.UnreadByte(); err != nil {
4440 return err
4441 }
4442 t.Steps[i] = new(Pipeline_Step)
4443 if err := t.Steps[i].UnmarshalCBOR(cr); err != nil {
4444 return xerrors.Errorf("unmarshaling t.Steps[i] pointer: %w", err)
4445 }
4446 }
4447
4448 }
4449
4450 }
4451 }
4452 // t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice)
4453 case "environment":
4454
4455 maj, extra, err = cr.ReadHeader()
4456 if err != nil {
4457 return err
4458 }
4459
4460 if extra > 8192 {
4461 return fmt.Errorf("t.Environment: array too large (%d)", extra)
4462 }
4463
4464 if maj != cbg.MajArray {
4465 return fmt.Errorf("expected cbor array")
4466 }
4467
4468 if extra > 0 {
4469 t.Environment = make([]*Pipeline_Workflow_Environment_Elem, extra)
4470 }
4471
4472 for i := 0; i < int(extra); i++ {
4473 {
4474 var maj byte
4475 var extra uint64
4476 var err error
4477 _ = maj
4478 _ = extra
4479 _ = err
4480
4481 {
4482
4483 b, err := cr.ReadByte()
4484 if err != nil {
4485 return err
4486 }
4487 if b != cbg.CborNull[0] {
4488 if err := cr.UnreadByte(); err != nil {
4489 return err
4490 }
4491 t.Environment[i] = new(Pipeline_Workflow_Environment_Elem)
4492 if err := t.Environment[i].UnmarshalCBOR(cr); err != nil {
4493 return xerrors.Errorf("unmarshaling t.Environment[i] pointer: %w", err)
4494 }
4495 }
4496
4497 }
4498
4499 }
4500 }
4501 // t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice)
4502 case "dependencies":
4503
4504 maj, extra, err = cr.ReadHeader()
4505 if err != nil {
4506 return err
4507 }
4508
4509 if extra > 8192 {
4510 return fmt.Errorf("t.Dependencies: array too large (%d)", extra)
4511 }
4512
4513 if maj != cbg.MajArray {
4514 return fmt.Errorf("expected cbor array")
4515 }
4516
4517 if extra > 0 {
4518 t.Dependencies = make([]Pipeline_Dependencies_Elem, extra)
4519 }
4520
4521 for i := 0; i < int(extra); i++ {
4522 {
4523 var maj byte
4524 var extra uint64
4525 var err error
4526 _ = maj
4527 _ = extra
4528 _ = err
4529
4530 {
4531
4532 if err := t.Dependencies[i].UnmarshalCBOR(cr); err != nil {
4533 return xerrors.Errorf("unmarshaling t.Dependencies[i]: %w", err)
4534 }
4535
4536 }
4537
4538 }
4539 }
4540
4541 default:
4542 // Field doesn't exist on this type, so ignore it
4543 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4544 return err
4545 }
4546 }
4547 }
4548
4549 return nil
4550}
4551func (t *Pipeline_Workflow_Environment_Elem) MarshalCBOR(w io.Writer) error {
4552 if t == nil {
4553 _, err := w.Write(cbg.CborNull)
4554 return err
4555 }
4556
4557 cw := cbg.NewCborWriter(w)
4558
4559 if _, err := cw.Write([]byte{162}); err != nil {
4560 return err
4561 }
4562
4563 // t.Key (string) (string)
4564 if len("key") > 1000000 {
4565 return xerrors.Errorf("Value in field \"key\" was too long")
4566 }
4567
4568 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
4569 return err
4570 }
4571 if _, err := cw.WriteString(string("key")); err != nil {
4572 return err
4573 }
4574
4575 if len(t.Key) > 1000000 {
4576 return xerrors.Errorf("Value in field t.Key was too long")
4577 }
4578
4579 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
4580 return err
4581 }
4582 if _, err := cw.WriteString(string(t.Key)); err != nil {
4583 return err
4584 }
4585
4586 // t.Value (string) (string)
4587 if len("value") > 1000000 {
4588 return xerrors.Errorf("Value in field \"value\" was too long")
4589 }
4590
4591 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
4592 return err
4593 }
4594 if _, err := cw.WriteString(string("value")); err != nil {
4595 return err
4596 }
4597
4598 if len(t.Value) > 1000000 {
4599 return xerrors.Errorf("Value in field t.Value was too long")
4600 }
4601
4602 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
4603 return err
4604 }
4605 if _, err := cw.WriteString(string(t.Value)); err != nil {
4606 return err
4607 }
4608 return nil
4609}
4610
4611func (t *Pipeline_Workflow_Environment_Elem) UnmarshalCBOR(r io.Reader) (err error) {
4612 *t = Pipeline_Workflow_Environment_Elem{}
4613
4614 cr := cbg.NewCborReader(r)
4615
4616 maj, extra, err := cr.ReadHeader()
4617 if err != nil {
4618 return err
4619 }
4620 defer func() {
4621 if err == io.EOF {
4622 err = io.ErrUnexpectedEOF
4623 }
4624 }()
4625
4626 if maj != cbg.MajMap {
4627 return fmt.Errorf("cbor input should be of type map")
4628 }
4629
4630 if extra > cbg.MaxLength {
4631 return fmt.Errorf("Pipeline_Workflow_Environment_Elem: map struct too large (%d)", extra)
4632 }
4633
4634 n := extra
4635
4636 nameBuf := make([]byte, 5)
4637 for i := uint64(0); i < n; i++ {
4638 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4639 if err != nil {
4640 return err
4641 }
4642
4643 if !ok {
4644 // Field doesn't exist on this type, so ignore it
4645 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4646 return err
4647 }
4648 continue
4649 }
4650
4651 switch string(nameBuf[:nameLen]) {
4652 // t.Key (string) (string)
4653 case "key":
4654
4655 {
4656 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4657 if err != nil {
4658 return err
4659 }
4660
4661 t.Key = string(sval)
4662 }
4663 // t.Value (string) (string)
4664 case "value":
4665
4666 {
4667 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4668 if err != nil {
4669 return err
4670 }
4671
4672 t.Value = string(sval)
4673 }
4674
4675 default:
4676 // Field doesn't exist on this type, so ignore it
4677 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4678 return err
4679 }
4680 }
4681 }
4682
4683 return nil
4684}
4685func (t *PublicKey) MarshalCBOR(w io.Writer) error {
4686 if t == nil {
4687 _, err := w.Write(cbg.CborNull)
4688 return err
4689 }
4690
4691 cw := cbg.NewCborWriter(w)
4692
4693 if _, err := cw.Write([]byte{164}); err != nil {
4694 return err
4695 }
4696
4697 // t.Key (string) (string)
4698 if len("key") > 1000000 {
4699 return xerrors.Errorf("Value in field \"key\" was too long")
4700 }
4701
4702 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
4703 return err
4704 }
4705 if _, err := cw.WriteString(string("key")); err != nil {
4706 return err
4707 }
4708
4709 if len(t.Key) > 1000000 {
4710 return xerrors.Errorf("Value in field t.Key was too long")
4711 }
4712
4713 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
4714 return err
4715 }
4716 if _, err := cw.WriteString(string(t.Key)); err != nil {
4717 return err
4718 }
4719
4720 // t.Name (string) (string)
4721 if len("name") > 1000000 {
4722 return xerrors.Errorf("Value in field \"name\" was too long")
4723 }
4724
4725 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
4726 return err
4727 }
4728 if _, err := cw.WriteString(string("name")); err != nil {
4729 return err
4730 }
4731
4732 if len(t.Name) > 1000000 {
4733 return xerrors.Errorf("Value in field t.Name was too long")
4734 }
4735
4736 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
4737 return err
4738 }
4739 if _, err := cw.WriteString(string(t.Name)); err != nil {
4740 return err
4741 }
4742
4743 // t.LexiconTypeID (string) (string)
4744 if len("$type") > 1000000 {
4745 return xerrors.Errorf("Value in field \"$type\" was too long")
4746 }
4747
4748 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
4749 return err
4750 }
4751 if _, err := cw.WriteString(string("$type")); err != nil {
4752 return err
4753 }
4754
4755 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil {
4756 return err
4757 }
4758 if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil {
4759 return err
4760 }
4761
4762 // t.CreatedAt (string) (string)
4763 if len("createdAt") > 1000000 {
4764 return xerrors.Errorf("Value in field \"createdAt\" was too long")
4765 }
4766
4767 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
4768 return err
4769 }
4770 if _, err := cw.WriteString(string("createdAt")); err != nil {
4771 return err
4772 }
4773
4774 if len(t.CreatedAt) > 1000000 {
4775 return xerrors.Errorf("Value in field t.CreatedAt was too long")
4776 }
4777
4778 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
4779 return err
4780 }
4781 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
4782 return err
4783 }
4784 return nil
4785}
4786
4787func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) {
4788 *t = PublicKey{}
4789
4790 cr := cbg.NewCborReader(r)
4791
4792 maj, extra, err := cr.ReadHeader()
4793 if err != nil {
4794 return err
4795 }
4796 defer func() {
4797 if err == io.EOF {
4798 err = io.ErrUnexpectedEOF
4799 }
4800 }()
4801
4802 if maj != cbg.MajMap {
4803 return fmt.Errorf("cbor input should be of type map")
4804 }
4805
4806 if extra > cbg.MaxLength {
4807 return fmt.Errorf("PublicKey: map struct too large (%d)", extra)
4808 }
4809
4810 n := extra
4811
4812 nameBuf := make([]byte, 9)
4813 for i := uint64(0); i < n; i++ {
4814 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4815 if err != nil {
4816 return err
4817 }
4818
4819 if !ok {
4820 // Field doesn't exist on this type, so ignore it
4821 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4822 return err
4823 }
4824 continue
4825 }
4826
4827 switch string(nameBuf[:nameLen]) {
4828 // t.Key (string) (string)
4829 case "key":
4830
4831 {
4832 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4833 if err != nil {
4834 return err
4835 }
4836
4837 t.Key = string(sval)
4838 }
4839 // t.Name (string) (string)
4840 case "name":
4841
4842 {
4843 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4844 if err != nil {
4845 return err
4846 }
4847
4848 t.Name = string(sval)
4849 }
4850 // t.LexiconTypeID (string) (string)
4851 case "$type":
4852
4853 {
4854 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4855 if err != nil {
4856 return err
4857 }
4858
4859 t.LexiconTypeID = string(sval)
4860 }
4861 // t.CreatedAt (string) (string)
4862 case "createdAt":
4863
4864 {
4865 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4866 if err != nil {
4867 return err
4868 }
4869
4870 t.CreatedAt = string(sval)
4871 }
4872
4873 default:
4874 // Field doesn't exist on this type, so ignore it
4875 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4876 return err
4877 }
4878 }
4879 }
4880
4881 return nil
4882}
4883func (t *Repo) MarshalCBOR(w io.Writer) error {
4884 if t == nil {
4885 _, err := w.Write(cbg.CborNull)
4886 return err
4887 }
4888
4889 cw := cbg.NewCborWriter(w)
4890 fieldCount := 8
4891
4892 if t.Description == nil {
4893 fieldCount--
4894 }
4895
4896 if t.Source == nil {
4897 fieldCount--
4898 }
4899
4900 if t.Spindle == nil {
4901 fieldCount--
4902 }
4903
4904 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4905 return err
4906 }
4907
4908 // t.Knot (string) (string)
4909 if len("knot") > 1000000 {
4910 return xerrors.Errorf("Value in field \"knot\" was too long")
4911 }
4912
4913 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
4914 return err
4915 }
4916 if _, err := cw.WriteString(string("knot")); err != nil {
4917 return err
4918 }
4919
4920 if len(t.Knot) > 1000000 {
4921 return xerrors.Errorf("Value in field t.Knot was too long")
4922 }
4923
4924 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
4925 return err
4926 }
4927 if _, err := cw.WriteString(string(t.Knot)); err != nil {
4928 return err
4929 }
4930
4931 // t.Name (string) (string)
4932 if len("name") > 1000000 {
4933 return xerrors.Errorf("Value in field \"name\" was too long")
4934 }
4935
4936 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
4937 return err
4938 }
4939 if _, err := cw.WriteString(string("name")); err != nil {
4940 return err
4941 }
4942
4943 if len(t.Name) > 1000000 {
4944 return xerrors.Errorf("Value in field t.Name was too long")
4945 }
4946
4947 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
4948 return err
4949 }
4950 if _, err := cw.WriteString(string(t.Name)); err != nil {
4951 return err
4952 }
4953
4954 // t.LexiconTypeID (string) (string)
4955 if len("$type") > 1000000 {
4956 return xerrors.Errorf("Value in field \"$type\" was too long")
4957 }
4958
4959 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
4960 return err
4961 }
4962 if _, err := cw.WriteString(string("$type")); err != nil {
4963 return err
4964 }
4965
4966 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil {
4967 return err
4968 }
4969 if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil {
4970 return err
4971 }
4972
4973 // t.Owner (string) (string)
4974 if len("owner") > 1000000 {
4975 return xerrors.Errorf("Value in field \"owner\" was too long")
4976 }
4977
4978 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
4979 return err
4980 }
4981 if _, err := cw.WriteString(string("owner")); err != nil {
4982 return err
4983 }
4984
4985 if len(t.Owner) > 1000000 {
4986 return xerrors.Errorf("Value in field t.Owner was too long")
4987 }
4988
4989 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {
4990 return err
4991 }
4992 if _, err := cw.WriteString(string(t.Owner)); err != nil {
4993 return err
4994 }
4995
4996 // t.Source (string) (string)
4997 if t.Source != nil {
4998
4999 if len("source") > 1000000 {
5000 return xerrors.Errorf("Value in field \"source\" was too long")
5001 }
5002
5003 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
5004 return err
5005 }
5006 if _, err := cw.WriteString(string("source")); err != nil {
5007 return err
5008 }
5009
5010 if t.Source == nil {
5011 if _, err := cw.Write(cbg.CborNull); err != nil {
5012 return err
5013 }
5014 } else {
5015 if len(*t.Source) > 1000000 {
5016 return xerrors.Errorf("Value in field t.Source was too long")
5017 }
5018
5019 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil {
5020 return err
5021 }
5022 if _, err := cw.WriteString(string(*t.Source)); err != nil {
5023 return err
5024 }
5025 }
5026 }
5027
5028 // t.Spindle (string) (string)
5029 if t.Spindle != nil {
5030
5031 if len("spindle") > 1000000 {
5032 return xerrors.Errorf("Value in field \"spindle\" was too long")
5033 }
5034
5035 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("spindle"))); err != nil {
5036 return err
5037 }
5038 if _, err := cw.WriteString(string("spindle")); err != nil {
5039 return err
5040 }
5041
5042 if t.Spindle == nil {
5043 if _, err := cw.Write(cbg.CborNull); err != nil {
5044 return err
5045 }
5046 } else {
5047 if len(*t.Spindle) > 1000000 {
5048 return xerrors.Errorf("Value in field t.Spindle was too long")
5049 }
5050
5051 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Spindle))); err != nil {
5052 return err
5053 }
5054 if _, err := cw.WriteString(string(*t.Spindle)); err != nil {
5055 return err
5056 }
5057 }
5058 }
5059
5060 // t.CreatedAt (string) (string)
5061 if len("createdAt") > 1000000 {
5062 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5063 }
5064
5065 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5066 return err
5067 }
5068 if _, err := cw.WriteString(string("createdAt")); err != nil {
5069 return err
5070 }
5071
5072 if len(t.CreatedAt) > 1000000 {
5073 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5074 }
5075
5076 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5077 return err
5078 }
5079 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5080 return err
5081 }
5082
5083 // t.Description (string) (string)
5084 if t.Description != nil {
5085
5086 if len("description") > 1000000 {
5087 return xerrors.Errorf("Value in field \"description\" was too long")
5088 }
5089
5090 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
5091 return err
5092 }
5093 if _, err := cw.WriteString(string("description")); err != nil {
5094 return err
5095 }
5096
5097 if t.Description == nil {
5098 if _, err := cw.Write(cbg.CborNull); err != nil {
5099 return err
5100 }
5101 } else {
5102 if len(*t.Description) > 1000000 {
5103 return xerrors.Errorf("Value in field t.Description was too long")
5104 }
5105
5106 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
5107 return err
5108 }
5109 if _, err := cw.WriteString(string(*t.Description)); err != nil {
5110 return err
5111 }
5112 }
5113 }
5114 return nil
5115}
5116
5117func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) {
5118 *t = Repo{}
5119
5120 cr := cbg.NewCborReader(r)
5121
5122 maj, extra, err := cr.ReadHeader()
5123 if err != nil {
5124 return err
5125 }
5126 defer func() {
5127 if err == io.EOF {
5128 err = io.ErrUnexpectedEOF
5129 }
5130 }()
5131
5132 if maj != cbg.MajMap {
5133 return fmt.Errorf("cbor input should be of type map")
5134 }
5135
5136 if extra > cbg.MaxLength {
5137 return fmt.Errorf("Repo: map struct too large (%d)", extra)
5138 }
5139
5140 n := extra
5141
5142 nameBuf := make([]byte, 11)
5143 for i := uint64(0); i < n; i++ {
5144 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5145 if err != nil {
5146 return err
5147 }
5148
5149 if !ok {
5150 // Field doesn't exist on this type, so ignore it
5151 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5152 return err
5153 }
5154 continue
5155 }
5156
5157 switch string(nameBuf[:nameLen]) {
5158 // t.Knot (string) (string)
5159 case "knot":
5160
5161 {
5162 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5163 if err != nil {
5164 return err
5165 }
5166
5167 t.Knot = string(sval)
5168 }
5169 // t.Name (string) (string)
5170 case "name":
5171
5172 {
5173 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5174 if err != nil {
5175 return err
5176 }
5177
5178 t.Name = string(sval)
5179 }
5180 // t.LexiconTypeID (string) (string)
5181 case "$type":
5182
5183 {
5184 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5185 if err != nil {
5186 return err
5187 }
5188
5189 t.LexiconTypeID = string(sval)
5190 }
5191 // t.Owner (string) (string)
5192 case "owner":
5193
5194 {
5195 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5196 if err != nil {
5197 return err
5198 }
5199
5200 t.Owner = string(sval)
5201 }
5202 // t.Source (string) (string)
5203 case "source":
5204
5205 {
5206 b, err := cr.ReadByte()
5207 if err != nil {
5208 return err
5209 }
5210 if b != cbg.CborNull[0] {
5211 if err := cr.UnreadByte(); err != nil {
5212 return err
5213 }
5214
5215 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5216 if err != nil {
5217 return err
5218 }
5219
5220 t.Source = (*string)(&sval)
5221 }
5222 }
5223 // t.Spindle (string) (string)
5224 case "spindle":
5225
5226 {
5227 b, err := cr.ReadByte()
5228 if err != nil {
5229 return err
5230 }
5231 if b != cbg.CborNull[0] {
5232 if err := cr.UnreadByte(); err != nil {
5233 return err
5234 }
5235
5236 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5237 if err != nil {
5238 return err
5239 }
5240
5241 t.Spindle = (*string)(&sval)
5242 }
5243 }
5244 // t.CreatedAt (string) (string)
5245 case "createdAt":
5246
5247 {
5248 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5249 if err != nil {
5250 return err
5251 }
5252
5253 t.CreatedAt = string(sval)
5254 }
5255 // t.Description (string) (string)
5256 case "description":
5257
5258 {
5259 b, err := cr.ReadByte()
5260 if err != nil {
5261 return err
5262 }
5263 if b != cbg.CborNull[0] {
5264 if err := cr.UnreadByte(); err != nil {
5265 return err
5266 }
5267
5268 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5269 if err != nil {
5270 return err
5271 }
5272
5273 t.Description = (*string)(&sval)
5274 }
5275 }
5276
5277 default:
5278 // Field doesn't exist on this type, so ignore it
5279 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5280 return err
5281 }
5282 }
5283 }
5284
5285 return nil
5286}
5287func (t *RepoArtifact) MarshalCBOR(w io.Writer) error {
5288 if t == nil {
5289 _, err := w.Write(cbg.CborNull)
5290 return err
5291 }
5292
5293 cw := cbg.NewCborWriter(w)
5294 fieldCount := 6
5295
5296 if t.Tag == nil {
5297 fieldCount--
5298 }
5299
5300 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5301 return err
5302 }
5303
5304 // t.Tag (util.LexBytes) (slice)
5305 if t.Tag != nil {
5306
5307 if len("tag") > 1000000 {
5308 return xerrors.Errorf("Value in field \"tag\" was too long")
5309 }
5310
5311 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tag"))); err != nil {
5312 return err
5313 }
5314 if _, err := cw.WriteString(string("tag")); err != nil {
5315 return err
5316 }
5317
5318 if len(t.Tag) > 2097152 {
5319 return xerrors.Errorf("Byte array in field t.Tag was too long")
5320 }
5321
5322 if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Tag))); err != nil {
5323 return err
5324 }
5325
5326 if _, err := cw.Write(t.Tag); err != nil {
5327 return err
5328 }
5329
5330 }
5331
5332 // t.Name (string) (string)
5333 if len("name") > 1000000 {
5334 return xerrors.Errorf("Value in field \"name\" was too long")
5335 }
5336
5337 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5338 return err
5339 }
5340 if _, err := cw.WriteString(string("name")); err != nil {
5341 return err
5342 }
5343
5344 if len(t.Name) > 1000000 {
5345 return xerrors.Errorf("Value in field t.Name was too long")
5346 }
5347
5348 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5349 return err
5350 }
5351 if _, err := cw.WriteString(string(t.Name)); err != nil {
5352 return err
5353 }
5354
5355 // t.Repo (string) (string)
5356 if len("repo") > 1000000 {
5357 return xerrors.Errorf("Value in field \"repo\" was too long")
5358 }
5359
5360 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5361 return err
5362 }
5363 if _, err := cw.WriteString(string("repo")); err != nil {
5364 return err
5365 }
5366
5367 if len(t.Repo) > 1000000 {
5368 return xerrors.Errorf("Value in field t.Repo was too long")
5369 }
5370
5371 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
5372 return err
5373 }
5374 if _, err := cw.WriteString(string(t.Repo)); err != nil {
5375 return err
5376 }
5377
5378 // t.LexiconTypeID (string) (string)
5379 if len("$type") > 1000000 {
5380 return xerrors.Errorf("Value in field \"$type\" was too long")
5381 }
5382
5383 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5384 return err
5385 }
5386 if _, err := cw.WriteString(string("$type")); err != nil {
5387 return err
5388 }
5389
5390 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.artifact"))); err != nil {
5391 return err
5392 }
5393 if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil {
5394 return err
5395 }
5396
5397 // t.Artifact (util.LexBlob) (struct)
5398 if len("artifact") > 1000000 {
5399 return xerrors.Errorf("Value in field \"artifact\" was too long")
5400 }
5401
5402 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("artifact"))); err != nil {
5403 return err
5404 }
5405 if _, err := cw.WriteString(string("artifact")); err != nil {
5406 return err
5407 }
5408
5409 if err := t.Artifact.MarshalCBOR(cw); err != nil {
5410 return err
5411 }
5412
5413 // t.CreatedAt (string) (string)
5414 if len("createdAt") > 1000000 {
5415 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5416 }
5417
5418 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5419 return err
5420 }
5421 if _, err := cw.WriteString(string("createdAt")); err != nil {
5422 return err
5423 }
5424
5425 if len(t.CreatedAt) > 1000000 {
5426 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5427 }
5428
5429 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5430 return err
5431 }
5432 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5433 return err
5434 }
5435 return nil
5436}
5437
5438func (t *RepoArtifact) UnmarshalCBOR(r io.Reader) (err error) {
5439 *t = RepoArtifact{}
5440
5441 cr := cbg.NewCborReader(r)
5442
5443 maj, extra, err := cr.ReadHeader()
5444 if err != nil {
5445 return err
5446 }
5447 defer func() {
5448 if err == io.EOF {
5449 err = io.ErrUnexpectedEOF
5450 }
5451 }()
5452
5453 if maj != cbg.MajMap {
5454 return fmt.Errorf("cbor input should be of type map")
5455 }
5456
5457 if extra > cbg.MaxLength {
5458 return fmt.Errorf("RepoArtifact: map struct too large (%d)", extra)
5459 }
5460
5461 n := extra
5462
5463 nameBuf := make([]byte, 9)
5464 for i := uint64(0); i < n; i++ {
5465 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5466 if err != nil {
5467 return err
5468 }
5469
5470 if !ok {
5471 // Field doesn't exist on this type, so ignore it
5472 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5473 return err
5474 }
5475 continue
5476 }
5477
5478 switch string(nameBuf[:nameLen]) {
5479 // t.Tag (util.LexBytes) (slice)
5480 case "tag":
5481
5482 maj, extra, err = cr.ReadHeader()
5483 if err != nil {
5484 return err
5485 }
5486
5487 if extra > 2097152 {
5488 return fmt.Errorf("t.Tag: byte array too large (%d)", extra)
5489 }
5490 if maj != cbg.MajByteString {
5491 return fmt.Errorf("expected byte array")
5492 }
5493
5494 if extra > 0 {
5495 t.Tag = make([]uint8, extra)
5496 }
5497
5498 if _, err := io.ReadFull(cr, t.Tag); err != nil {
5499 return err
5500 }
5501
5502 // t.Name (string) (string)
5503 case "name":
5504
5505 {
5506 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5507 if err != nil {
5508 return err
5509 }
5510
5511 t.Name = string(sval)
5512 }
5513 // t.Repo (string) (string)
5514 case "repo":
5515
5516 {
5517 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5518 if err != nil {
5519 return err
5520 }
5521
5522 t.Repo = string(sval)
5523 }
5524 // t.LexiconTypeID (string) (string)
5525 case "$type":
5526
5527 {
5528 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5529 if err != nil {
5530 return err
5531 }
5532
5533 t.LexiconTypeID = string(sval)
5534 }
5535 // t.Artifact (util.LexBlob) (struct)
5536 case "artifact":
5537
5538 {
5539
5540 b, err := cr.ReadByte()
5541 if err != nil {
5542 return err
5543 }
5544 if b != cbg.CborNull[0] {
5545 if err := cr.UnreadByte(); err != nil {
5546 return err
5547 }
5548 t.Artifact = new(util.LexBlob)
5549 if err := t.Artifact.UnmarshalCBOR(cr); err != nil {
5550 return xerrors.Errorf("unmarshaling t.Artifact pointer: %w", err)
5551 }
5552 }
5553
5554 }
5555 // t.CreatedAt (string) (string)
5556 case "createdAt":
5557
5558 {
5559 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5560 if err != nil {
5561 return err
5562 }
5563
5564 t.CreatedAt = string(sval)
5565 }
5566
5567 default:
5568 // Field doesn't exist on this type, so ignore it
5569 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5570 return err
5571 }
5572 }
5573 }
5574
5575 return nil
5576}
5577func (t *RepoIssue) MarshalCBOR(w io.Writer) error {
5578 if t == nil {
5579 _, err := w.Write(cbg.CborNull)
5580 return err
5581 }
5582
5583 cw := cbg.NewCborWriter(w)
5584 fieldCount := 7
5585
5586 if t.Body == nil {
5587 fieldCount--
5588 }
5589
5590 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5591 return err
5592 }
5593
5594 // t.Body (string) (string)
5595 if t.Body != nil {
5596
5597 if len("body") > 1000000 {
5598 return xerrors.Errorf("Value in field \"body\" was too long")
5599 }
5600
5601 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
5602 return err
5603 }
5604 if _, err := cw.WriteString(string("body")); err != nil {
5605 return err
5606 }
5607
5608 if t.Body == nil {
5609 if _, err := cw.Write(cbg.CborNull); err != nil {
5610 return err
5611 }
5612 } else {
5613 if len(*t.Body) > 1000000 {
5614 return xerrors.Errorf("Value in field t.Body was too long")
5615 }
5616
5617 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
5618 return err
5619 }
5620 if _, err := cw.WriteString(string(*t.Body)); err != nil {
5621 return err
5622 }
5623 }
5624 }
5625
5626 // t.Repo (string) (string)
5627 if len("repo") > 1000000 {
5628 return xerrors.Errorf("Value in field \"repo\" was too long")
5629 }
5630
5631 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5632 return err
5633 }
5634 if _, err := cw.WriteString(string("repo")); err != nil {
5635 return err
5636 }
5637
5638 if len(t.Repo) > 1000000 {
5639 return xerrors.Errorf("Value in field t.Repo was too long")
5640 }
5641
5642 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
5643 return err
5644 }
5645 if _, err := cw.WriteString(string(t.Repo)); err != nil {
5646 return err
5647 }
5648
5649 // t.LexiconTypeID (string) (string)
5650 if len("$type") > 1000000 {
5651 return xerrors.Errorf("Value in field \"$type\" was too long")
5652 }
5653
5654 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5655 return err
5656 }
5657 if _, err := cw.WriteString(string("$type")); err != nil {
5658 return err
5659 }
5660
5661 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil {
5662 return err
5663 }
5664 if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil {
5665 return err
5666 }
5667
5668 // t.Owner (string) (string)
5669 if len("owner") > 1000000 {
5670 return xerrors.Errorf("Value in field \"owner\" was too long")
5671 }
5672
5673 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
5674 return err
5675 }
5676 if _, err := cw.WriteString(string("owner")); err != nil {
5677 return err
5678 }
5679
5680 if len(t.Owner) > 1000000 {
5681 return xerrors.Errorf("Value in field t.Owner was too long")
5682 }
5683
5684 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {
5685 return err
5686 }
5687 if _, err := cw.WriteString(string(t.Owner)); err != nil {
5688 return err
5689 }
5690
5691 // t.Title (string) (string)
5692 if len("title") > 1000000 {
5693 return xerrors.Errorf("Value in field \"title\" was too long")
5694 }
5695
5696 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
5697 return err
5698 }
5699 if _, err := cw.WriteString(string("title")); err != nil {
5700 return err
5701 }
5702
5703 if len(t.Title) > 1000000 {
5704 return xerrors.Errorf("Value in field t.Title was too long")
5705 }
5706
5707 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
5708 return err
5709 }
5710 if _, err := cw.WriteString(string(t.Title)); err != nil {
5711 return err
5712 }
5713
5714 // t.IssueId (int64) (int64)
5715 if len("issueId") > 1000000 {
5716 return xerrors.Errorf("Value in field \"issueId\" was too long")
5717 }
5718
5719 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issueId"))); err != nil {
5720 return err
5721 }
5722 if _, err := cw.WriteString(string("issueId")); err != nil {
5723 return err
5724 }
5725
5726 if t.IssueId >= 0 {
5727 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.IssueId)); err != nil {
5728 return err
5729 }
5730 } else {
5731 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.IssueId-1)); err != nil {
5732 return err
5733 }
5734 }
5735
5736 // t.CreatedAt (string) (string)
5737 if len("createdAt") > 1000000 {
5738 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5739 }
5740
5741 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5742 return err
5743 }
5744 if _, err := cw.WriteString(string("createdAt")); err != nil {
5745 return err
5746 }
5747
5748 if len(t.CreatedAt) > 1000000 {
5749 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5750 }
5751
5752 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5753 return err
5754 }
5755 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5756 return err
5757 }
5758 return nil
5759}
5760
5761func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) {
5762 *t = RepoIssue{}
5763
5764 cr := cbg.NewCborReader(r)
5765
5766 maj, extra, err := cr.ReadHeader()
5767 if err != nil {
5768 return err
5769 }
5770 defer func() {
5771 if err == io.EOF {
5772 err = io.ErrUnexpectedEOF
5773 }
5774 }()
5775
5776 if maj != cbg.MajMap {
5777 return fmt.Errorf("cbor input should be of type map")
5778 }
5779
5780 if extra > cbg.MaxLength {
5781 return fmt.Errorf("RepoIssue: map struct too large (%d)", extra)
5782 }
5783
5784 n := extra
5785
5786 nameBuf := make([]byte, 9)
5787 for i := uint64(0); i < n; i++ {
5788 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5789 if err != nil {
5790 return err
5791 }
5792
5793 if !ok {
5794 // Field doesn't exist on this type, so ignore it
5795 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5796 return err
5797 }
5798 continue
5799 }
5800
5801 switch string(nameBuf[:nameLen]) {
5802 // t.Body (string) (string)
5803 case "body":
5804
5805 {
5806 b, err := cr.ReadByte()
5807 if err != nil {
5808 return err
5809 }
5810 if b != cbg.CborNull[0] {
5811 if err := cr.UnreadByte(); err != nil {
5812 return err
5813 }
5814
5815 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5816 if err != nil {
5817 return err
5818 }
5819
5820 t.Body = (*string)(&sval)
5821 }
5822 }
5823 // t.Repo (string) (string)
5824 case "repo":
5825
5826 {
5827 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5828 if err != nil {
5829 return err
5830 }
5831
5832 t.Repo = string(sval)
5833 }
5834 // t.LexiconTypeID (string) (string)
5835 case "$type":
5836
5837 {
5838 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5839 if err != nil {
5840 return err
5841 }
5842
5843 t.LexiconTypeID = string(sval)
5844 }
5845 // t.Owner (string) (string)
5846 case "owner":
5847
5848 {
5849 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5850 if err != nil {
5851 return err
5852 }
5853
5854 t.Owner = string(sval)
5855 }
5856 // t.Title (string) (string)
5857 case "title":
5858
5859 {
5860 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5861 if err != nil {
5862 return err
5863 }
5864
5865 t.Title = string(sval)
5866 }
5867 // t.IssueId (int64) (int64)
5868 case "issueId":
5869 {
5870 maj, extra, err := cr.ReadHeader()
5871 if err != nil {
5872 return err
5873 }
5874 var extraI int64
5875 switch maj {
5876 case cbg.MajUnsignedInt:
5877 extraI = int64(extra)
5878 if extraI < 0 {
5879 return fmt.Errorf("int64 positive overflow")
5880 }
5881 case cbg.MajNegativeInt:
5882 extraI = int64(extra)
5883 if extraI < 0 {
5884 return fmt.Errorf("int64 negative overflow")
5885 }
5886 extraI = -1 - extraI
5887 default:
5888 return fmt.Errorf("wrong type for int64 field: %d", maj)
5889 }
5890
5891 t.IssueId = int64(extraI)
5892 }
5893 // t.CreatedAt (string) (string)
5894 case "createdAt":
5895
5896 {
5897 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5898 if err != nil {
5899 return err
5900 }
5901
5902 t.CreatedAt = string(sval)
5903 }
5904
5905 default:
5906 // Field doesn't exist on this type, so ignore it
5907 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5908 return err
5909 }
5910 }
5911 }
5912
5913 return nil
5914}
5915func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error {
5916 if t == nil {
5917 _, err := w.Write(cbg.CborNull)
5918 return err
5919 }
5920
5921 cw := cbg.NewCborWriter(w)
5922 fieldCount := 7
5923
5924 if t.CommentId == nil {
5925 fieldCount--
5926 }
5927
5928 if t.Owner == nil {
5929 fieldCount--
5930 }
5931
5932 if t.Repo == nil {
5933 fieldCount--
5934 }
5935
5936 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5937 return err
5938 }
5939
5940 // t.Body (string) (string)
5941 if len("body") > 1000000 {
5942 return xerrors.Errorf("Value in field \"body\" was too long")
5943 }
5944
5945 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
5946 return err
5947 }
5948 if _, err := cw.WriteString(string("body")); err != nil {
5949 return err
5950 }
5951
5952 if len(t.Body) > 1000000 {
5953 return xerrors.Errorf("Value in field t.Body was too long")
5954 }
5955
5956 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
5957 return err
5958 }
5959 if _, err := cw.WriteString(string(t.Body)); err != nil {
5960 return err
5961 }
5962
5963 // t.Repo (string) (string)
5964 if t.Repo != nil {
5965
5966 if len("repo") > 1000000 {
5967 return xerrors.Errorf("Value in field \"repo\" was too long")
5968 }
5969
5970 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5971 return err
5972 }
5973 if _, err := cw.WriteString(string("repo")); err != nil {
5974 return err
5975 }
5976
5977 if t.Repo == nil {
5978 if _, err := cw.Write(cbg.CborNull); err != nil {
5979 return err
5980 }
5981 } else {
5982 if len(*t.Repo) > 1000000 {
5983 return xerrors.Errorf("Value in field t.Repo was too long")
5984 }
5985
5986 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
5987 return err
5988 }
5989 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
5990 return err
5991 }
5992 }
5993 }
5994
5995 // t.LexiconTypeID (string) (string)
5996 if len("$type") > 1000000 {
5997 return xerrors.Errorf("Value in field \"$type\" was too long")
5998 }
5999
6000 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6001 return err
6002 }
6003 if _, err := cw.WriteString(string("$type")); err != nil {
6004 return err
6005 }
6006
6007 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil {
6008 return err
6009 }
6010 if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil {
6011 return err
6012 }
6013
6014 // t.Issue (string) (string)
6015 if len("issue") > 1000000 {
6016 return xerrors.Errorf("Value in field \"issue\" was too long")
6017 }
6018
6019 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
6020 return err
6021 }
6022 if _, err := cw.WriteString(string("issue")); err != nil {
6023 return err
6024 }
6025
6026 if len(t.Issue) > 1000000 {
6027 return xerrors.Errorf("Value in field t.Issue was too long")
6028 }
6029
6030 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
6031 return err
6032 }
6033 if _, err := cw.WriteString(string(t.Issue)); err != nil {
6034 return err
6035 }
6036
6037 // t.Owner (string) (string)
6038 if t.Owner != nil {
6039
6040 if len("owner") > 1000000 {
6041 return xerrors.Errorf("Value in field \"owner\" was too long")
6042 }
6043
6044 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
6045 return err
6046 }
6047 if _, err := cw.WriteString(string("owner")); err != nil {
6048 return err
6049 }
6050
6051 if t.Owner == nil {
6052 if _, err := cw.Write(cbg.CborNull); err != nil {
6053 return err
6054 }
6055 } else {
6056 if len(*t.Owner) > 1000000 {
6057 return xerrors.Errorf("Value in field t.Owner was too long")
6058 }
6059
6060 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Owner))); err != nil {
6061 return err
6062 }
6063 if _, err := cw.WriteString(string(*t.Owner)); err != nil {
6064 return err
6065 }
6066 }
6067 }
6068
6069 // t.CommentId (int64) (int64)
6070 if t.CommentId != nil {
6071
6072 if len("commentId") > 1000000 {
6073 return xerrors.Errorf("Value in field \"commentId\" was too long")
6074 }
6075
6076 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commentId"))); err != nil {
6077 return err
6078 }
6079 if _, err := cw.WriteString(string("commentId")); err != nil {
6080 return err
6081 }
6082
6083 if t.CommentId == nil {
6084 if _, err := cw.Write(cbg.CborNull); err != nil {
6085 return err
6086 }
6087 } else {
6088 if *t.CommentId >= 0 {
6089 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.CommentId)); err != nil {
6090 return err
6091 }
6092 } else {
6093 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.CommentId-1)); err != nil {
6094 return err
6095 }
6096 }
6097 }
6098
6099 }
6100
6101 // t.CreatedAt (string) (string)
6102 if len("createdAt") > 1000000 {
6103 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6104 }
6105
6106 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6107 return err
6108 }
6109 if _, err := cw.WriteString(string("createdAt")); err != nil {
6110 return err
6111 }
6112
6113 if len(t.CreatedAt) > 1000000 {
6114 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6115 }
6116
6117 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6118 return err
6119 }
6120 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6121 return err
6122 }
6123 return nil
6124}
6125
6126func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) {
6127 *t = RepoIssueComment{}
6128
6129 cr := cbg.NewCborReader(r)
6130
6131 maj, extra, err := cr.ReadHeader()
6132 if err != nil {
6133 return err
6134 }
6135 defer func() {
6136 if err == io.EOF {
6137 err = io.ErrUnexpectedEOF
6138 }
6139 }()
6140
6141 if maj != cbg.MajMap {
6142 return fmt.Errorf("cbor input should be of type map")
6143 }
6144
6145 if extra > cbg.MaxLength {
6146 return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra)
6147 }
6148
6149 n := extra
6150
6151 nameBuf := make([]byte, 9)
6152 for i := uint64(0); i < n; i++ {
6153 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6154 if err != nil {
6155 return err
6156 }
6157
6158 if !ok {
6159 // Field doesn't exist on this type, so ignore it
6160 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6161 return err
6162 }
6163 continue
6164 }
6165
6166 switch string(nameBuf[:nameLen]) {
6167 // t.Body (string) (string)
6168 case "body":
6169
6170 {
6171 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6172 if err != nil {
6173 return err
6174 }
6175
6176 t.Body = string(sval)
6177 }
6178 // t.Repo (string) (string)
6179 case "repo":
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
6191 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6192 if err != nil {
6193 return err
6194 }
6195
6196 t.Repo = (*string)(&sval)
6197 }
6198 }
6199 // t.LexiconTypeID (string) (string)
6200 case "$type":
6201
6202 {
6203 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6204 if err != nil {
6205 return err
6206 }
6207
6208 t.LexiconTypeID = string(sval)
6209 }
6210 // t.Issue (string) (string)
6211 case "issue":
6212
6213 {
6214 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6215 if err != nil {
6216 return err
6217 }
6218
6219 t.Issue = string(sval)
6220 }
6221 // t.Owner (string) (string)
6222 case "owner":
6223
6224 {
6225 b, err := cr.ReadByte()
6226 if err != nil {
6227 return err
6228 }
6229 if b != cbg.CborNull[0] {
6230 if err := cr.UnreadByte(); err != nil {
6231 return err
6232 }
6233
6234 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6235 if err != nil {
6236 return err
6237 }
6238
6239 t.Owner = (*string)(&sval)
6240 }
6241 }
6242 // t.CommentId (int64) (int64)
6243 case "commentId":
6244 {
6245
6246 b, err := cr.ReadByte()
6247 if err != nil {
6248 return err
6249 }
6250 if b != cbg.CborNull[0] {
6251 if err := cr.UnreadByte(); err != nil {
6252 return err
6253 }
6254 maj, extra, err := cr.ReadHeader()
6255 if err != nil {
6256 return err
6257 }
6258 var extraI int64
6259 switch maj {
6260 case cbg.MajUnsignedInt:
6261 extraI = int64(extra)
6262 if extraI < 0 {
6263 return fmt.Errorf("int64 positive overflow")
6264 }
6265 case cbg.MajNegativeInt:
6266 extraI = int64(extra)
6267 if extraI < 0 {
6268 return fmt.Errorf("int64 negative overflow")
6269 }
6270 extraI = -1 - extraI
6271 default:
6272 return fmt.Errorf("wrong type for int64 field: %d", maj)
6273 }
6274
6275 t.CommentId = (*int64)(&extraI)
6276 }
6277 }
6278 // t.CreatedAt (string) (string)
6279 case "createdAt":
6280
6281 {
6282 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6283 if err != nil {
6284 return err
6285 }
6286
6287 t.CreatedAt = string(sval)
6288 }
6289
6290 default:
6291 // Field doesn't exist on this type, so ignore it
6292 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6293 return err
6294 }
6295 }
6296 }
6297
6298 return nil
6299}
6300func (t *RepoIssueState) MarshalCBOR(w io.Writer) error {
6301 if t == nil {
6302 _, err := w.Write(cbg.CborNull)
6303 return err
6304 }
6305
6306 cw := cbg.NewCborWriter(w)
6307
6308 if _, err := cw.Write([]byte{163}); err != nil {
6309 return err
6310 }
6311
6312 // t.LexiconTypeID (string) (string)
6313 if len("$type") > 1000000 {
6314 return xerrors.Errorf("Value in field \"$type\" was too long")
6315 }
6316
6317 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6318 return err
6319 }
6320 if _, err := cw.WriteString(string("$type")); err != nil {
6321 return err
6322 }
6323
6324 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil {
6325 return err
6326 }
6327 if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil {
6328 return err
6329 }
6330
6331 // t.Issue (string) (string)
6332 if len("issue") > 1000000 {
6333 return xerrors.Errorf("Value in field \"issue\" was too long")
6334 }
6335
6336 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
6337 return err
6338 }
6339 if _, err := cw.WriteString(string("issue")); err != nil {
6340 return err
6341 }
6342
6343 if len(t.Issue) > 1000000 {
6344 return xerrors.Errorf("Value in field t.Issue was too long")
6345 }
6346
6347 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
6348 return err
6349 }
6350 if _, err := cw.WriteString(string(t.Issue)); err != nil {
6351 return err
6352 }
6353
6354 // t.State (string) (string)
6355 if len("state") > 1000000 {
6356 return xerrors.Errorf("Value in field \"state\" was too long")
6357 }
6358
6359 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil {
6360 return err
6361 }
6362 if _, err := cw.WriteString(string("state")); err != nil {
6363 return err
6364 }
6365
6366 if len(t.State) > 1000000 {
6367 return xerrors.Errorf("Value in field t.State was too long")
6368 }
6369
6370 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil {
6371 return err
6372 }
6373 if _, err := cw.WriteString(string(t.State)); err != nil {
6374 return err
6375 }
6376 return nil
6377}
6378
6379func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) {
6380 *t = RepoIssueState{}
6381
6382 cr := cbg.NewCborReader(r)
6383
6384 maj, extra, err := cr.ReadHeader()
6385 if err != nil {
6386 return err
6387 }
6388 defer func() {
6389 if err == io.EOF {
6390 err = io.ErrUnexpectedEOF
6391 }
6392 }()
6393
6394 if maj != cbg.MajMap {
6395 return fmt.Errorf("cbor input should be of type map")
6396 }
6397
6398 if extra > cbg.MaxLength {
6399 return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra)
6400 }
6401
6402 n := extra
6403
6404 nameBuf := make([]byte, 5)
6405 for i := uint64(0); i < n; i++ {
6406 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6407 if err != nil {
6408 return err
6409 }
6410
6411 if !ok {
6412 // Field doesn't exist on this type, so ignore it
6413 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6414 return err
6415 }
6416 continue
6417 }
6418
6419 switch string(nameBuf[:nameLen]) {
6420 // t.LexiconTypeID (string) (string)
6421 case "$type":
6422
6423 {
6424 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6425 if err != nil {
6426 return err
6427 }
6428
6429 t.LexiconTypeID = string(sval)
6430 }
6431 // t.Issue (string) (string)
6432 case "issue":
6433
6434 {
6435 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6436 if err != nil {
6437 return err
6438 }
6439
6440 t.Issue = string(sval)
6441 }
6442 // t.State (string) (string)
6443 case "state":
6444
6445 {
6446 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6447 if err != nil {
6448 return err
6449 }
6450
6451 t.State = string(sval)
6452 }
6453
6454 default:
6455 // Field doesn't exist on this type, so ignore it
6456 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6457 return err
6458 }
6459 }
6460 }
6461
6462 return nil
6463}
6464func (t *RepoPull) MarshalCBOR(w io.Writer) error {
6465 if t == nil {
6466 _, err := w.Write(cbg.CborNull)
6467 return err
6468 }
6469
6470 cw := cbg.NewCborWriter(w)
6471 fieldCount := 9
6472
6473 if t.Body == nil {
6474 fieldCount--
6475 }
6476
6477 if t.Source == nil {
6478 fieldCount--
6479 }
6480
6481 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6482 return err
6483 }
6484
6485 // t.Body (string) (string)
6486 if t.Body != nil {
6487
6488 if len("body") > 1000000 {
6489 return xerrors.Errorf("Value in field \"body\" was too long")
6490 }
6491
6492 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
6493 return err
6494 }
6495 if _, err := cw.WriteString(string("body")); err != nil {
6496 return err
6497 }
6498
6499 if t.Body == nil {
6500 if _, err := cw.Write(cbg.CborNull); err != nil {
6501 return err
6502 }
6503 } else {
6504 if len(*t.Body) > 1000000 {
6505 return xerrors.Errorf("Value in field t.Body was too long")
6506 }
6507
6508 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
6509 return err
6510 }
6511 if _, err := cw.WriteString(string(*t.Body)); err != nil {
6512 return err
6513 }
6514 }
6515 }
6516
6517 // t.LexiconTypeID (string) (string)
6518 if len("$type") > 1000000 {
6519 return xerrors.Errorf("Value in field \"$type\" was too long")
6520 }
6521
6522 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6523 return err
6524 }
6525 if _, err := cw.WriteString(string("$type")); err != nil {
6526 return err
6527 }
6528
6529 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil {
6530 return err
6531 }
6532 if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil {
6533 return err
6534 }
6535
6536 // t.Patch (string) (string)
6537 if len("patch") > 1000000 {
6538 return xerrors.Errorf("Value in field \"patch\" was too long")
6539 }
6540
6541 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil {
6542 return err
6543 }
6544 if _, err := cw.WriteString(string("patch")); err != nil {
6545 return err
6546 }
6547
6548 if len(t.Patch) > 1000000 {
6549 return xerrors.Errorf("Value in field t.Patch was too long")
6550 }
6551
6552 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Patch))); err != nil {
6553 return err
6554 }
6555 if _, err := cw.WriteString(string(t.Patch)); err != nil {
6556 return err
6557 }
6558
6559 // t.Title (string) (string)
6560 if len("title") > 1000000 {
6561 return xerrors.Errorf("Value in field \"title\" was too long")
6562 }
6563
6564 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
6565 return err
6566 }
6567 if _, err := cw.WriteString(string("title")); err != nil {
6568 return err
6569 }
6570
6571 if len(t.Title) > 1000000 {
6572 return xerrors.Errorf("Value in field t.Title was too long")
6573 }
6574
6575 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
6576 return err
6577 }
6578 if _, err := cw.WriteString(string(t.Title)); err != nil {
6579 return err
6580 }
6581
6582 // t.PullId (int64) (int64)
6583 if len("pullId") > 1000000 {
6584 return xerrors.Errorf("Value in field \"pullId\" was too long")
6585 }
6586
6587 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullId"))); err != nil {
6588 return err
6589 }
6590 if _, err := cw.WriteString(string("pullId")); err != nil {
6591 return err
6592 }
6593
6594 if t.PullId >= 0 {
6595 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.PullId)); err != nil {
6596 return err
6597 }
6598 } else {
6599 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.PullId-1)); err != nil {
6600 return err
6601 }
6602 }
6603
6604 // t.Source (tangled.RepoPull_Source) (struct)
6605 if t.Source != nil {
6606
6607 if len("source") > 1000000 {
6608 return xerrors.Errorf("Value in field \"source\" was too long")
6609 }
6610
6611 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
6612 return err
6613 }
6614 if _, err := cw.WriteString(string("source")); err != nil {
6615 return err
6616 }
6617
6618 if err := t.Source.MarshalCBOR(cw); err != nil {
6619 return err
6620 }
6621 }
6622
6623 // t.CreatedAt (string) (string)
6624 if len("createdAt") > 1000000 {
6625 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6626 }
6627
6628 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6629 return err
6630 }
6631 if _, err := cw.WriteString(string("createdAt")); err != nil {
6632 return err
6633 }
6634
6635 if len(t.CreatedAt) > 1000000 {
6636 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6637 }
6638
6639 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6640 return err
6641 }
6642 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6643 return err
6644 }
6645
6646 // t.TargetRepo (string) (string)
6647 if len("targetRepo") > 1000000 {
6648 return xerrors.Errorf("Value in field \"targetRepo\" was too long")
6649 }
6650
6651 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetRepo"))); err != nil {
6652 return err
6653 }
6654 if _, err := cw.WriteString(string("targetRepo")); err != nil {
6655 return err
6656 }
6657
6658 if len(t.TargetRepo) > 1000000 {
6659 return xerrors.Errorf("Value in field t.TargetRepo was too long")
6660 }
6661
6662 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetRepo))); err != nil {
6663 return err
6664 }
6665 if _, err := cw.WriteString(string(t.TargetRepo)); err != nil {
6666 return err
6667 }
6668
6669 // t.TargetBranch (string) (string)
6670 if len("targetBranch") > 1000000 {
6671 return xerrors.Errorf("Value in field \"targetBranch\" was too long")
6672 }
6673
6674 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil {
6675 return err
6676 }
6677 if _, err := cw.WriteString(string("targetBranch")); err != nil {
6678 return err
6679 }
6680
6681 if len(t.TargetBranch) > 1000000 {
6682 return xerrors.Errorf("Value in field t.TargetBranch was too long")
6683 }
6684
6685 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil {
6686 return err
6687 }
6688 if _, err := cw.WriteString(string(t.TargetBranch)); err != nil {
6689 return err
6690 }
6691 return nil
6692}
6693
6694func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) {
6695 *t = RepoPull{}
6696
6697 cr := cbg.NewCborReader(r)
6698
6699 maj, extra, err := cr.ReadHeader()
6700 if err != nil {
6701 return err
6702 }
6703 defer func() {
6704 if err == io.EOF {
6705 err = io.ErrUnexpectedEOF
6706 }
6707 }()
6708
6709 if maj != cbg.MajMap {
6710 return fmt.Errorf("cbor input should be of type map")
6711 }
6712
6713 if extra > cbg.MaxLength {
6714 return fmt.Errorf("RepoPull: map struct too large (%d)", extra)
6715 }
6716
6717 n := extra
6718
6719 nameBuf := make([]byte, 12)
6720 for i := uint64(0); i < n; i++ {
6721 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6722 if err != nil {
6723 return err
6724 }
6725
6726 if !ok {
6727 // Field doesn't exist on this type, so ignore it
6728 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6729 return err
6730 }
6731 continue
6732 }
6733
6734 switch string(nameBuf[:nameLen]) {
6735 // t.Body (string) (string)
6736 case "body":
6737
6738 {
6739 b, err := cr.ReadByte()
6740 if err != nil {
6741 return err
6742 }
6743 if b != cbg.CborNull[0] {
6744 if err := cr.UnreadByte(); err != nil {
6745 return err
6746 }
6747
6748 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6749 if err != nil {
6750 return err
6751 }
6752
6753 t.Body = (*string)(&sval)
6754 }
6755 }
6756 // t.LexiconTypeID (string) (string)
6757 case "$type":
6758
6759 {
6760 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6761 if err != nil {
6762 return err
6763 }
6764
6765 t.LexiconTypeID = string(sval)
6766 }
6767 // t.Patch (string) (string)
6768 case "patch":
6769
6770 {
6771 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6772 if err != nil {
6773 return err
6774 }
6775
6776 t.Patch = string(sval)
6777 }
6778 // t.Title (string) (string)
6779 case "title":
6780
6781 {
6782 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6783 if err != nil {
6784 return err
6785 }
6786
6787 t.Title = string(sval)
6788 }
6789 // t.PullId (int64) (int64)
6790 case "pullId":
6791 {
6792 maj, extra, err := cr.ReadHeader()
6793 if err != nil {
6794 return err
6795 }
6796 var extraI int64
6797 switch maj {
6798 case cbg.MajUnsignedInt:
6799 extraI = int64(extra)
6800 if extraI < 0 {
6801 return fmt.Errorf("int64 positive overflow")
6802 }
6803 case cbg.MajNegativeInt:
6804 extraI = int64(extra)
6805 if extraI < 0 {
6806 return fmt.Errorf("int64 negative overflow")
6807 }
6808 extraI = -1 - extraI
6809 default:
6810 return fmt.Errorf("wrong type for int64 field: %d", maj)
6811 }
6812
6813 t.PullId = int64(extraI)
6814 }
6815 // t.Source (tangled.RepoPull_Source) (struct)
6816 case "source":
6817
6818 {
6819
6820 b, err := cr.ReadByte()
6821 if err != nil {
6822 return err
6823 }
6824 if b != cbg.CborNull[0] {
6825 if err := cr.UnreadByte(); err != nil {
6826 return err
6827 }
6828 t.Source = new(RepoPull_Source)
6829 if err := t.Source.UnmarshalCBOR(cr); err != nil {
6830 return xerrors.Errorf("unmarshaling t.Source pointer: %w", err)
6831 }
6832 }
6833
6834 }
6835 // t.CreatedAt (string) (string)
6836 case "createdAt":
6837
6838 {
6839 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6840 if err != nil {
6841 return err
6842 }
6843
6844 t.CreatedAt = string(sval)
6845 }
6846 // t.TargetRepo (string) (string)
6847 case "targetRepo":
6848
6849 {
6850 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6851 if err != nil {
6852 return err
6853 }
6854
6855 t.TargetRepo = string(sval)
6856 }
6857 // t.TargetBranch (string) (string)
6858 case "targetBranch":
6859
6860 {
6861 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6862 if err != nil {
6863 return err
6864 }
6865
6866 t.TargetBranch = string(sval)
6867 }
6868
6869 default:
6870 // Field doesn't exist on this type, so ignore it
6871 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6872 return err
6873 }
6874 }
6875 }
6876
6877 return nil
6878}
6879func (t *RepoPullComment) MarshalCBOR(w io.Writer) error {
6880 if t == nil {
6881 _, err := w.Write(cbg.CborNull)
6882 return err
6883 }
6884
6885 cw := cbg.NewCborWriter(w)
6886 fieldCount := 7
6887
6888 if t.CommentId == nil {
6889 fieldCount--
6890 }
6891
6892 if t.Owner == nil {
6893 fieldCount--
6894 }
6895
6896 if t.Repo == nil {
6897 fieldCount--
6898 }
6899
6900 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6901 return err
6902 }
6903
6904 // t.Body (string) (string)
6905 if len("body") > 1000000 {
6906 return xerrors.Errorf("Value in field \"body\" was too long")
6907 }
6908
6909 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
6910 return err
6911 }
6912 if _, err := cw.WriteString(string("body")); err != nil {
6913 return err
6914 }
6915
6916 if len(t.Body) > 1000000 {
6917 return xerrors.Errorf("Value in field t.Body was too long")
6918 }
6919
6920 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
6921 return err
6922 }
6923 if _, err := cw.WriteString(string(t.Body)); err != nil {
6924 return err
6925 }
6926
6927 // t.Pull (string) (string)
6928 if len("pull") > 1000000 {
6929 return xerrors.Errorf("Value in field \"pull\" was too long")
6930 }
6931
6932 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
6933 return err
6934 }
6935 if _, err := cw.WriteString(string("pull")); err != nil {
6936 return err
6937 }
6938
6939 if len(t.Pull) > 1000000 {
6940 return xerrors.Errorf("Value in field t.Pull was too long")
6941 }
6942
6943 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
6944 return err
6945 }
6946 if _, err := cw.WriteString(string(t.Pull)); err != nil {
6947 return err
6948 }
6949
6950 // t.Repo (string) (string)
6951 if t.Repo != nil {
6952
6953 if len("repo") > 1000000 {
6954 return xerrors.Errorf("Value in field \"repo\" was too long")
6955 }
6956
6957 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6958 return err
6959 }
6960 if _, err := cw.WriteString(string("repo")); err != nil {
6961 return err
6962 }
6963
6964 if t.Repo == nil {
6965 if _, err := cw.Write(cbg.CborNull); err != nil {
6966 return err
6967 }
6968 } else {
6969 if len(*t.Repo) > 1000000 {
6970 return xerrors.Errorf("Value in field t.Repo was too long")
6971 }
6972
6973 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
6974 return err
6975 }
6976 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
6977 return err
6978 }
6979 }
6980 }
6981
6982 // t.LexiconTypeID (string) (string)
6983 if len("$type") > 1000000 {
6984 return xerrors.Errorf("Value in field \"$type\" was too long")
6985 }
6986
6987 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6988 return err
6989 }
6990 if _, err := cw.WriteString(string("$type")); err != nil {
6991 return err
6992 }
6993
6994 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.comment"))); err != nil {
6995 return err
6996 }
6997 if _, err := cw.WriteString(string("sh.tangled.repo.pull.comment")); err != nil {
6998 return err
6999 }
7000
7001 // t.Owner (string) (string)
7002 if t.Owner != nil {
7003
7004 if len("owner") > 1000000 {
7005 return xerrors.Errorf("Value in field \"owner\" was too long")
7006 }
7007
7008 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
7009 return err
7010 }
7011 if _, err := cw.WriteString(string("owner")); err != nil {
7012 return err
7013 }
7014
7015 if t.Owner == nil {
7016 if _, err := cw.Write(cbg.CborNull); err != nil {
7017 return err
7018 }
7019 } else {
7020 if len(*t.Owner) > 1000000 {
7021 return xerrors.Errorf("Value in field t.Owner was too long")
7022 }
7023
7024 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Owner))); err != nil {
7025 return err
7026 }
7027 if _, err := cw.WriteString(string(*t.Owner)); err != nil {
7028 return err
7029 }
7030 }
7031 }
7032
7033 // t.CommentId (int64) (int64)
7034 if t.CommentId != nil {
7035
7036 if len("commentId") > 1000000 {
7037 return xerrors.Errorf("Value in field \"commentId\" was too long")
7038 }
7039
7040 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commentId"))); err != nil {
7041 return err
7042 }
7043 if _, err := cw.WriteString(string("commentId")); err != nil {
7044 return err
7045 }
7046
7047 if t.CommentId == nil {
7048 if _, err := cw.Write(cbg.CborNull); err != nil {
7049 return err
7050 }
7051 } else {
7052 if *t.CommentId >= 0 {
7053 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.CommentId)); err != nil {
7054 return err
7055 }
7056 } else {
7057 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.CommentId-1)); err != nil {
7058 return err
7059 }
7060 }
7061 }
7062
7063 }
7064
7065 // t.CreatedAt (string) (string)
7066 if len("createdAt") > 1000000 {
7067 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7068 }
7069
7070 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7071 return err
7072 }
7073 if _, err := cw.WriteString(string("createdAt")); err != nil {
7074 return err
7075 }
7076
7077 if len(t.CreatedAt) > 1000000 {
7078 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7079 }
7080
7081 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7082 return err
7083 }
7084 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7085 return err
7086 }
7087 return nil
7088}
7089
7090func (t *RepoPullComment) UnmarshalCBOR(r io.Reader) (err error) {
7091 *t = RepoPullComment{}
7092
7093 cr := cbg.NewCborReader(r)
7094
7095 maj, extra, err := cr.ReadHeader()
7096 if err != nil {
7097 return err
7098 }
7099 defer func() {
7100 if err == io.EOF {
7101 err = io.ErrUnexpectedEOF
7102 }
7103 }()
7104
7105 if maj != cbg.MajMap {
7106 return fmt.Errorf("cbor input should be of type map")
7107 }
7108
7109 if extra > cbg.MaxLength {
7110 return fmt.Errorf("RepoPullComment: map struct too large (%d)", extra)
7111 }
7112
7113 n := extra
7114
7115 nameBuf := make([]byte, 9)
7116 for i := uint64(0); i < n; i++ {
7117 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7118 if err != nil {
7119 return err
7120 }
7121
7122 if !ok {
7123 // Field doesn't exist on this type, so ignore it
7124 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7125 return err
7126 }
7127 continue
7128 }
7129
7130 switch string(nameBuf[:nameLen]) {
7131 // t.Body (string) (string)
7132 case "body":
7133
7134 {
7135 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7136 if err != nil {
7137 return err
7138 }
7139
7140 t.Body = string(sval)
7141 }
7142 // t.Pull (string) (string)
7143 case "pull":
7144
7145 {
7146 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7147 if err != nil {
7148 return err
7149 }
7150
7151 t.Pull = string(sval)
7152 }
7153 // t.Repo (string) (string)
7154 case "repo":
7155
7156 {
7157 b, err := cr.ReadByte()
7158 if err != nil {
7159 return err
7160 }
7161 if b != cbg.CborNull[0] {
7162 if err := cr.UnreadByte(); err != nil {
7163 return err
7164 }
7165
7166 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7167 if err != nil {
7168 return err
7169 }
7170
7171 t.Repo = (*string)(&sval)
7172 }
7173 }
7174 // t.LexiconTypeID (string) (string)
7175 case "$type":
7176
7177 {
7178 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7179 if err != nil {
7180 return err
7181 }
7182
7183 t.LexiconTypeID = string(sval)
7184 }
7185 // t.Owner (string) (string)
7186 case "owner":
7187
7188 {
7189 b, err := cr.ReadByte()
7190 if err != nil {
7191 return err
7192 }
7193 if b != cbg.CborNull[0] {
7194 if err := cr.UnreadByte(); err != nil {
7195 return err
7196 }
7197
7198 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7199 if err != nil {
7200 return err
7201 }
7202
7203 t.Owner = (*string)(&sval)
7204 }
7205 }
7206 // t.CommentId (int64) (int64)
7207 case "commentId":
7208 {
7209
7210 b, err := cr.ReadByte()
7211 if err != nil {
7212 return err
7213 }
7214 if b != cbg.CborNull[0] {
7215 if err := cr.UnreadByte(); err != nil {
7216 return err
7217 }
7218 maj, extra, err := cr.ReadHeader()
7219 if err != nil {
7220 return err
7221 }
7222 var extraI int64
7223 switch maj {
7224 case cbg.MajUnsignedInt:
7225 extraI = int64(extra)
7226 if extraI < 0 {
7227 return fmt.Errorf("int64 positive overflow")
7228 }
7229 case cbg.MajNegativeInt:
7230 extraI = int64(extra)
7231 if extraI < 0 {
7232 return fmt.Errorf("int64 negative overflow")
7233 }
7234 extraI = -1 - extraI
7235 default:
7236 return fmt.Errorf("wrong type for int64 field: %d", maj)
7237 }
7238
7239 t.CommentId = (*int64)(&extraI)
7240 }
7241 }
7242 // t.CreatedAt (string) (string)
7243 case "createdAt":
7244
7245 {
7246 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7247 if err != nil {
7248 return err
7249 }
7250
7251 t.CreatedAt = string(sval)
7252 }
7253
7254 default:
7255 // Field doesn't exist on this type, so ignore it
7256 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7257 return err
7258 }
7259 }
7260 }
7261
7262 return nil
7263}
7264func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error {
7265 if t == nil {
7266 _, err := w.Write(cbg.CborNull)
7267 return err
7268 }
7269
7270 cw := cbg.NewCborWriter(w)
7271 fieldCount := 2
7272
7273 if t.Repo == nil {
7274 fieldCount--
7275 }
7276
7277 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7278 return err
7279 }
7280
7281 // t.Repo (string) (string)
7282 if t.Repo != nil {
7283
7284 if len("repo") > 1000000 {
7285 return xerrors.Errorf("Value in field \"repo\" was too long")
7286 }
7287
7288 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
7289 return err
7290 }
7291 if _, err := cw.WriteString(string("repo")); err != nil {
7292 return err
7293 }
7294
7295 if t.Repo == nil {
7296 if _, err := cw.Write(cbg.CborNull); err != nil {
7297 return err
7298 }
7299 } else {
7300 if len(*t.Repo) > 1000000 {
7301 return xerrors.Errorf("Value in field t.Repo was too long")
7302 }
7303
7304 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
7305 return err
7306 }
7307 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
7308 return err
7309 }
7310 }
7311 }
7312
7313 // t.Branch (string) (string)
7314 if len("branch") > 1000000 {
7315 return xerrors.Errorf("Value in field \"branch\" was too long")
7316 }
7317
7318 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
7319 return err
7320 }
7321 if _, err := cw.WriteString(string("branch")); err != nil {
7322 return err
7323 }
7324
7325 if len(t.Branch) > 1000000 {
7326 return xerrors.Errorf("Value in field t.Branch was too long")
7327 }
7328
7329 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
7330 return err
7331 }
7332 if _, err := cw.WriteString(string(t.Branch)); err != nil {
7333 return err
7334 }
7335 return nil
7336}
7337
7338func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) {
7339 *t = RepoPull_Source{}
7340
7341 cr := cbg.NewCborReader(r)
7342
7343 maj, extra, err := cr.ReadHeader()
7344 if err != nil {
7345 return err
7346 }
7347 defer func() {
7348 if err == io.EOF {
7349 err = io.ErrUnexpectedEOF
7350 }
7351 }()
7352
7353 if maj != cbg.MajMap {
7354 return fmt.Errorf("cbor input should be of type map")
7355 }
7356
7357 if extra > cbg.MaxLength {
7358 return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra)
7359 }
7360
7361 n := extra
7362
7363 nameBuf := make([]byte, 6)
7364 for i := uint64(0); i < n; i++ {
7365 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7366 if err != nil {
7367 return err
7368 }
7369
7370 if !ok {
7371 // Field doesn't exist on this type, so ignore it
7372 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7373 return err
7374 }
7375 continue
7376 }
7377
7378 switch string(nameBuf[:nameLen]) {
7379 // t.Repo (string) (string)
7380 case "repo":
7381
7382 {
7383 b, err := cr.ReadByte()
7384 if err != nil {
7385 return err
7386 }
7387 if b != cbg.CborNull[0] {
7388 if err := cr.UnreadByte(); err != nil {
7389 return err
7390 }
7391
7392 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7393 if err != nil {
7394 return err
7395 }
7396
7397 t.Repo = (*string)(&sval)
7398 }
7399 }
7400 // t.Branch (string) (string)
7401 case "branch":
7402
7403 {
7404 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7405 if err != nil {
7406 return err
7407 }
7408
7409 t.Branch = string(sval)
7410 }
7411
7412 default:
7413 // Field doesn't exist on this type, so ignore it
7414 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7415 return err
7416 }
7417 }
7418 }
7419
7420 return nil
7421}
7422func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error {
7423 if t == nil {
7424 _, err := w.Write(cbg.CborNull)
7425 return err
7426 }
7427
7428 cw := cbg.NewCborWriter(w)
7429
7430 if _, err := cw.Write([]byte{163}); err != nil {
7431 return err
7432 }
7433
7434 // t.Pull (string) (string)
7435 if len("pull") > 1000000 {
7436 return xerrors.Errorf("Value in field \"pull\" was too long")
7437 }
7438
7439 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
7440 return err
7441 }
7442 if _, err := cw.WriteString(string("pull")); err != nil {
7443 return err
7444 }
7445
7446 if len(t.Pull) > 1000000 {
7447 return xerrors.Errorf("Value in field t.Pull was too long")
7448 }
7449
7450 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
7451 return err
7452 }
7453 if _, err := cw.WriteString(string(t.Pull)); err != nil {
7454 return err
7455 }
7456
7457 // t.LexiconTypeID (string) (string)
7458 if len("$type") > 1000000 {
7459 return xerrors.Errorf("Value in field \"$type\" was too long")
7460 }
7461
7462 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7463 return err
7464 }
7465 if _, err := cw.WriteString(string("$type")); err != nil {
7466 return err
7467 }
7468
7469 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil {
7470 return err
7471 }
7472 if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil {
7473 return err
7474 }
7475
7476 // t.Status (string) (string)
7477 if len("status") > 1000000 {
7478 return xerrors.Errorf("Value in field \"status\" was too long")
7479 }
7480
7481 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
7482 return err
7483 }
7484 if _, err := cw.WriteString(string("status")); err != nil {
7485 return err
7486 }
7487
7488 if len(t.Status) > 1000000 {
7489 return xerrors.Errorf("Value in field t.Status was too long")
7490 }
7491
7492 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
7493 return err
7494 }
7495 if _, err := cw.WriteString(string(t.Status)); err != nil {
7496 return err
7497 }
7498 return nil
7499}
7500
7501func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) {
7502 *t = RepoPullStatus{}
7503
7504 cr := cbg.NewCborReader(r)
7505
7506 maj, extra, err := cr.ReadHeader()
7507 if err != nil {
7508 return err
7509 }
7510 defer func() {
7511 if err == io.EOF {
7512 err = io.ErrUnexpectedEOF
7513 }
7514 }()
7515
7516 if maj != cbg.MajMap {
7517 return fmt.Errorf("cbor input should be of type map")
7518 }
7519
7520 if extra > cbg.MaxLength {
7521 return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra)
7522 }
7523
7524 n := extra
7525
7526 nameBuf := make([]byte, 6)
7527 for i := uint64(0); i < n; i++ {
7528 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7529 if err != nil {
7530 return err
7531 }
7532
7533 if !ok {
7534 // Field doesn't exist on this type, so ignore it
7535 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7536 return err
7537 }
7538 continue
7539 }
7540
7541 switch string(nameBuf[:nameLen]) {
7542 // t.Pull (string) (string)
7543 case "pull":
7544
7545 {
7546 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7547 if err != nil {
7548 return err
7549 }
7550
7551 t.Pull = string(sval)
7552 }
7553 // t.LexiconTypeID (string) (string)
7554 case "$type":
7555
7556 {
7557 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7558 if err != nil {
7559 return err
7560 }
7561
7562 t.LexiconTypeID = string(sval)
7563 }
7564 // t.Status (string) (string)
7565 case "status":
7566
7567 {
7568 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7569 if err != nil {
7570 return err
7571 }
7572
7573 t.Status = string(sval)
7574 }
7575
7576 default:
7577 // Field doesn't exist on this type, so ignore it
7578 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7579 return err
7580 }
7581 }
7582 }
7583
7584 return nil
7585}
7586func (t *Spindle) MarshalCBOR(w io.Writer) error {
7587 if t == nil {
7588 _, err := w.Write(cbg.CborNull)
7589 return err
7590 }
7591
7592 cw := cbg.NewCborWriter(w)
7593
7594 if _, err := cw.Write([]byte{162}); err != nil {
7595 return err
7596 }
7597
7598 // t.LexiconTypeID (string) (string)
7599 if len("$type") > 1000000 {
7600 return xerrors.Errorf("Value in field \"$type\" was too long")
7601 }
7602
7603 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7604 return err
7605 }
7606 if _, err := cw.WriteString(string("$type")); err != nil {
7607 return err
7608 }
7609
7610 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle"))); err != nil {
7611 return err
7612 }
7613 if _, err := cw.WriteString(string("sh.tangled.spindle")); err != nil {
7614 return err
7615 }
7616
7617 // t.CreatedAt (string) (string)
7618 if len("createdAt") > 1000000 {
7619 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7620 }
7621
7622 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7623 return err
7624 }
7625 if _, err := cw.WriteString(string("createdAt")); err != nil {
7626 return err
7627 }
7628
7629 if len(t.CreatedAt) > 1000000 {
7630 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7631 }
7632
7633 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7634 return err
7635 }
7636 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7637 return err
7638 }
7639 return nil
7640}
7641
7642func (t *Spindle) UnmarshalCBOR(r io.Reader) (err error) {
7643 *t = Spindle{}
7644
7645 cr := cbg.NewCborReader(r)
7646
7647 maj, extra, err := cr.ReadHeader()
7648 if err != nil {
7649 return err
7650 }
7651 defer func() {
7652 if err == io.EOF {
7653 err = io.ErrUnexpectedEOF
7654 }
7655 }()
7656
7657 if maj != cbg.MajMap {
7658 return fmt.Errorf("cbor input should be of type map")
7659 }
7660
7661 if extra > cbg.MaxLength {
7662 return fmt.Errorf("Spindle: map struct too large (%d)", extra)
7663 }
7664
7665 n := extra
7666
7667 nameBuf := make([]byte, 9)
7668 for i := uint64(0); i < n; i++ {
7669 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7670 if err != nil {
7671 return err
7672 }
7673
7674 if !ok {
7675 // Field doesn't exist on this type, so ignore it
7676 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7677 return err
7678 }
7679 continue
7680 }
7681
7682 switch string(nameBuf[:nameLen]) {
7683 // t.LexiconTypeID (string) (string)
7684 case "$type":
7685
7686 {
7687 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7688 if err != nil {
7689 return err
7690 }
7691
7692 t.LexiconTypeID = string(sval)
7693 }
7694 // t.CreatedAt (string) (string)
7695 case "createdAt":
7696
7697 {
7698 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7699 if err != nil {
7700 return err
7701 }
7702
7703 t.CreatedAt = string(sval)
7704 }
7705
7706 default:
7707 // Field doesn't exist on this type, so ignore it
7708 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7709 return err
7710 }
7711 }
7712 }
7713
7714 return nil
7715}
7716func (t *SpindleMember) MarshalCBOR(w io.Writer) error {
7717 if t == nil {
7718 _, err := w.Write(cbg.CborNull)
7719 return err
7720 }
7721
7722 cw := cbg.NewCborWriter(w)
7723
7724 if _, err := cw.Write([]byte{164}); err != nil {
7725 return err
7726 }
7727
7728 // t.LexiconTypeID (string) (string)
7729 if len("$type") > 1000000 {
7730 return xerrors.Errorf("Value in field \"$type\" was too long")
7731 }
7732
7733 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7734 return err
7735 }
7736 if _, err := cw.WriteString(string("$type")); err != nil {
7737 return err
7738 }
7739
7740 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle.member"))); err != nil {
7741 return err
7742 }
7743 if _, err := cw.WriteString(string("sh.tangled.spindle.member")); err != nil {
7744 return err
7745 }
7746
7747 // t.Subject (string) (string)
7748 if len("subject") > 1000000 {
7749 return xerrors.Errorf("Value in field \"subject\" was too long")
7750 }
7751
7752 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
7753 return err
7754 }
7755 if _, err := cw.WriteString(string("subject")); err != nil {
7756 return err
7757 }
7758
7759 if len(t.Subject) > 1000000 {
7760 return xerrors.Errorf("Value in field t.Subject was too long")
7761 }
7762
7763 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
7764 return err
7765 }
7766 if _, err := cw.WriteString(string(t.Subject)); err != nil {
7767 return err
7768 }
7769
7770 // t.Instance (string) (string)
7771 if len("instance") > 1000000 {
7772 return xerrors.Errorf("Value in field \"instance\" was too long")
7773 }
7774
7775 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("instance"))); err != nil {
7776 return err
7777 }
7778 if _, err := cw.WriteString(string("instance")); err != nil {
7779 return err
7780 }
7781
7782 if len(t.Instance) > 1000000 {
7783 return xerrors.Errorf("Value in field t.Instance was too long")
7784 }
7785
7786 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Instance))); err != nil {
7787 return err
7788 }
7789 if _, err := cw.WriteString(string(t.Instance)); err != nil {
7790 return err
7791 }
7792
7793 // t.CreatedAt (string) (string)
7794 if len("createdAt") > 1000000 {
7795 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7796 }
7797
7798 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7799 return err
7800 }
7801 if _, err := cw.WriteString(string("createdAt")); err != nil {
7802 return err
7803 }
7804
7805 if len(t.CreatedAt) > 1000000 {
7806 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7807 }
7808
7809 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7810 return err
7811 }
7812 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7813 return err
7814 }
7815 return nil
7816}
7817
7818func (t *SpindleMember) UnmarshalCBOR(r io.Reader) (err error) {
7819 *t = SpindleMember{}
7820
7821 cr := cbg.NewCborReader(r)
7822
7823 maj, extra, err := cr.ReadHeader()
7824 if err != nil {
7825 return err
7826 }
7827 defer func() {
7828 if err == io.EOF {
7829 err = io.ErrUnexpectedEOF
7830 }
7831 }()
7832
7833 if maj != cbg.MajMap {
7834 return fmt.Errorf("cbor input should be of type map")
7835 }
7836
7837 if extra > cbg.MaxLength {
7838 return fmt.Errorf("SpindleMember: map struct too large (%d)", extra)
7839 }
7840
7841 n := extra
7842
7843 nameBuf := make([]byte, 9)
7844 for i := uint64(0); i < n; i++ {
7845 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7846 if err != nil {
7847 return err
7848 }
7849
7850 if !ok {
7851 // Field doesn't exist on this type, so ignore it
7852 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7853 return err
7854 }
7855 continue
7856 }
7857
7858 switch string(nameBuf[:nameLen]) {
7859 // t.LexiconTypeID (string) (string)
7860 case "$type":
7861
7862 {
7863 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7864 if err != nil {
7865 return err
7866 }
7867
7868 t.LexiconTypeID = string(sval)
7869 }
7870 // t.Subject (string) (string)
7871 case "subject":
7872
7873 {
7874 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7875 if err != nil {
7876 return err
7877 }
7878
7879 t.Subject = string(sval)
7880 }
7881 // t.Instance (string) (string)
7882 case "instance":
7883
7884 {
7885 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7886 if err != nil {
7887 return err
7888 }
7889
7890 t.Instance = string(sval)
7891 }
7892 // t.CreatedAt (string) (string)
7893 case "createdAt":
7894
7895 {
7896 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7897 if err != nil {
7898 return err
7899 }
7900
7901 t.CreatedAt = string(sval)
7902 }
7903
7904 default:
7905 // Field doesn't exist on this type, so ignore it
7906 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7907 return err
7908 }
7909 }
7910 }
7911
7912 return nil
7913}