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