this repo has no description
tangled.org
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 *FeedReaction) 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{164}); 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.reaction"))); err != nil {
532 return err
533 }
534 if _, err := cw.WriteString(string("sh.tangled.feed.reaction")); 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.Reaction (string) (string)
562 if len("reaction") > 1000000 {
563 return xerrors.Errorf("Value in field \"reaction\" was too long")
564 }
565
566 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("reaction"))); err != nil {
567 return err
568 }
569 if _, err := cw.WriteString(string("reaction")); err != nil {
570 return err
571 }
572
573 if len(t.Reaction) > 1000000 {
574 return xerrors.Errorf("Value in field t.Reaction was too long")
575 }
576
577 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Reaction))); err != nil {
578 return err
579 }
580 if _, err := cw.WriteString(string(t.Reaction)); err != nil {
581 return err
582 }
583
584 // t.CreatedAt (string) (string)
585 if len("createdAt") > 1000000 {
586 return xerrors.Errorf("Value in field \"createdAt\" was too long")
587 }
588
589 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
590 return err
591 }
592 if _, err := cw.WriteString(string("createdAt")); err != nil {
593 return err
594 }
595
596 if len(t.CreatedAt) > 1000000 {
597 return xerrors.Errorf("Value in field t.CreatedAt was too long")
598 }
599
600 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
601 return err
602 }
603 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
604 return err
605 }
606 return nil
607}
608
609func (t *FeedReaction) UnmarshalCBOR(r io.Reader) (err error) {
610 *t = FeedReaction{}
611
612 cr := cbg.NewCborReader(r)
613
614 maj, extra, err := cr.ReadHeader()
615 if err != nil {
616 return err
617 }
618 defer func() {
619 if err == io.EOF {
620 err = io.ErrUnexpectedEOF
621 }
622 }()
623
624 if maj != cbg.MajMap {
625 return fmt.Errorf("cbor input should be of type map")
626 }
627
628 if extra > cbg.MaxLength {
629 return fmt.Errorf("FeedReaction: map struct too large (%d)", extra)
630 }
631
632 n := extra
633
634 nameBuf := make([]byte, 9)
635 for i := uint64(0); i < n; i++ {
636 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
637 if err != nil {
638 return err
639 }
640
641 if !ok {
642 // Field doesn't exist on this type, so ignore it
643 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
644 return err
645 }
646 continue
647 }
648
649 switch string(nameBuf[:nameLen]) {
650 // t.LexiconTypeID (string) (string)
651 case "$type":
652
653 {
654 sval, err := cbg.ReadStringWithMax(cr, 1000000)
655 if err != nil {
656 return err
657 }
658
659 t.LexiconTypeID = string(sval)
660 }
661 // t.Subject (string) (string)
662 case "subject":
663
664 {
665 sval, err := cbg.ReadStringWithMax(cr, 1000000)
666 if err != nil {
667 return err
668 }
669
670 t.Subject = string(sval)
671 }
672 // t.Reaction (string) (string)
673 case "reaction":
674
675 {
676 sval, err := cbg.ReadStringWithMax(cr, 1000000)
677 if err != nil {
678 return err
679 }
680
681 t.Reaction = string(sval)
682 }
683 // t.CreatedAt (string) (string)
684 case "createdAt":
685
686 {
687 sval, err := cbg.ReadStringWithMax(cr, 1000000)
688 if err != nil {
689 return err
690 }
691
692 t.CreatedAt = string(sval)
693 }
694
695 default:
696 // Field doesn't exist on this type, so ignore it
697 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
698 return err
699 }
700 }
701 }
702
703 return nil
704}
705func (t *FeedStar) MarshalCBOR(w io.Writer) error {
706 if t == nil {
707 _, err := w.Write(cbg.CborNull)
708 return err
709 }
710
711 cw := cbg.NewCborWriter(w)
712
713 if _, err := cw.Write([]byte{163}); err != nil {
714 return err
715 }
716
717 // t.LexiconTypeID (string) (string)
718 if len("$type") > 1000000 {
719 return xerrors.Errorf("Value in field \"$type\" was too long")
720 }
721
722 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
723 return err
724 }
725 if _, err := cw.WriteString(string("$type")); err != nil {
726 return err
727 }
728
729 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.star"))); err != nil {
730 return err
731 }
732 if _, err := cw.WriteString(string("sh.tangled.feed.star")); err != nil {
733 return err
734 }
735
736 // t.Subject (string) (string)
737 if len("subject") > 1000000 {
738 return xerrors.Errorf("Value in field \"subject\" was too long")
739 }
740
741 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
742 return err
743 }
744 if _, err := cw.WriteString(string("subject")); err != nil {
745 return err
746 }
747
748 if len(t.Subject) > 1000000 {
749 return xerrors.Errorf("Value in field t.Subject was too long")
750 }
751
752 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
753 return err
754 }
755 if _, err := cw.WriteString(string(t.Subject)); err != nil {
756 return err
757 }
758
759 // t.CreatedAt (string) (string)
760 if len("createdAt") > 1000000 {
761 return xerrors.Errorf("Value in field \"createdAt\" was too long")
762 }
763
764 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
765 return err
766 }
767 if _, err := cw.WriteString(string("createdAt")); err != nil {
768 return err
769 }
770
771 if len(t.CreatedAt) > 1000000 {
772 return xerrors.Errorf("Value in field t.CreatedAt was too long")
773 }
774
775 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
776 return err
777 }
778 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
779 return err
780 }
781 return nil
782}
783
784func (t *FeedStar) UnmarshalCBOR(r io.Reader) (err error) {
785 *t = FeedStar{}
786
787 cr := cbg.NewCborReader(r)
788
789 maj, extra, err := cr.ReadHeader()
790 if err != nil {
791 return err
792 }
793 defer func() {
794 if err == io.EOF {
795 err = io.ErrUnexpectedEOF
796 }
797 }()
798
799 if maj != cbg.MajMap {
800 return fmt.Errorf("cbor input should be of type map")
801 }
802
803 if extra > cbg.MaxLength {
804 return fmt.Errorf("FeedStar: map struct too large (%d)", extra)
805 }
806
807 n := extra
808
809 nameBuf := make([]byte, 9)
810 for i := uint64(0); i < n; i++ {
811 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
812 if err != nil {
813 return err
814 }
815
816 if !ok {
817 // Field doesn't exist on this type, so ignore it
818 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
819 return err
820 }
821 continue
822 }
823
824 switch string(nameBuf[:nameLen]) {
825 // t.LexiconTypeID (string) (string)
826 case "$type":
827
828 {
829 sval, err := cbg.ReadStringWithMax(cr, 1000000)
830 if err != nil {
831 return err
832 }
833
834 t.LexiconTypeID = string(sval)
835 }
836 // t.Subject (string) (string)
837 case "subject":
838
839 {
840 sval, err := cbg.ReadStringWithMax(cr, 1000000)
841 if err != nil {
842 return err
843 }
844
845 t.Subject = string(sval)
846 }
847 // t.CreatedAt (string) (string)
848 case "createdAt":
849
850 {
851 sval, err := cbg.ReadStringWithMax(cr, 1000000)
852 if err != nil {
853 return err
854 }
855
856 t.CreatedAt = string(sval)
857 }
858
859 default:
860 // Field doesn't exist on this type, so ignore it
861 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
862 return err
863 }
864 }
865 }
866
867 return nil
868}
869func (t *GitRefUpdate) MarshalCBOR(w io.Writer) error {
870 if t == nil {
871 _, err := w.Write(cbg.CborNull)
872 return err
873 }
874
875 cw := cbg.NewCborWriter(w)
876
877 if _, err := cw.Write([]byte{168}); err != nil {
878 return err
879 }
880
881 // t.Ref (string) (string)
882 if len("ref") > 1000000 {
883 return xerrors.Errorf("Value in field \"ref\" was too long")
884 }
885
886 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
887 return err
888 }
889 if _, err := cw.WriteString(string("ref")); err != nil {
890 return err
891 }
892
893 if len(t.Ref) > 1000000 {
894 return xerrors.Errorf("Value in field t.Ref was too long")
895 }
896
897 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
898 return err
899 }
900 if _, err := cw.WriteString(string(t.Ref)); err != nil {
901 return err
902 }
903
904 // t.Meta (tangled.GitRefUpdate_Meta) (struct)
905 if len("meta") > 1000000 {
906 return xerrors.Errorf("Value in field \"meta\" was too long")
907 }
908
909 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil {
910 return err
911 }
912 if _, err := cw.WriteString(string("meta")); err != nil {
913 return err
914 }
915
916 if err := t.Meta.MarshalCBOR(cw); err != nil {
917 return err
918 }
919
920 // t.LexiconTypeID (string) (string)
921 if len("$type") > 1000000 {
922 return xerrors.Errorf("Value in field \"$type\" was too long")
923 }
924
925 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
926 return err
927 }
928 if _, err := cw.WriteString(string("$type")); err != nil {
929 return err
930 }
931
932 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.git.refUpdate"))); err != nil {
933 return err
934 }
935 if _, err := cw.WriteString(string("sh.tangled.git.refUpdate")); err != nil {
936 return err
937 }
938
939 // t.NewSha (string) (string)
940 if len("newSha") > 1000000 {
941 return xerrors.Errorf("Value in field \"newSha\" was too long")
942 }
943
944 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
945 return err
946 }
947 if _, err := cw.WriteString(string("newSha")); err != nil {
948 return err
949 }
950
951 if len(t.NewSha) > 1000000 {
952 return xerrors.Errorf("Value in field t.NewSha was too long")
953 }
954
955 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
956 return err
957 }
958 if _, err := cw.WriteString(string(t.NewSha)); err != nil {
959 return err
960 }
961
962 // t.OldSha (string) (string)
963 if len("oldSha") > 1000000 {
964 return xerrors.Errorf("Value in field \"oldSha\" was too long")
965 }
966
967 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
968 return err
969 }
970 if _, err := cw.WriteString(string("oldSha")); err != nil {
971 return err
972 }
973
974 if len(t.OldSha) > 1000000 {
975 return xerrors.Errorf("Value in field t.OldSha was too long")
976 }
977
978 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
979 return err
980 }
981 if _, err := cw.WriteString(string(t.OldSha)); err != nil {
982 return err
983 }
984
985 // t.RepoDid (string) (string)
986 if len("repoDid") > 1000000 {
987 return xerrors.Errorf("Value in field \"repoDid\" was too long")
988 }
989
990 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
991 return err
992 }
993 if _, err := cw.WriteString(string("repoDid")); err != nil {
994 return err
995 }
996
997 if len(t.RepoDid) > 1000000 {
998 return xerrors.Errorf("Value in field t.RepoDid was too long")
999 }
1000
1001 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoDid))); err != nil {
1002 return err
1003 }
1004 if _, err := cw.WriteString(string(t.RepoDid)); err != nil {
1005 return err
1006 }
1007
1008 // t.RepoName (string) (string)
1009 if len("repoName") > 1000000 {
1010 return xerrors.Errorf("Value in field \"repoName\" was too long")
1011 }
1012
1013 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoName"))); err != nil {
1014 return err
1015 }
1016 if _, err := cw.WriteString(string("repoName")); err != nil {
1017 return err
1018 }
1019
1020 if len(t.RepoName) > 1000000 {
1021 return xerrors.Errorf("Value in field t.RepoName was too long")
1022 }
1023
1024 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoName))); err != nil {
1025 return err
1026 }
1027 if _, err := cw.WriteString(string(t.RepoName)); err != nil {
1028 return err
1029 }
1030
1031 // t.CommitterDid (string) (string)
1032 if len("committerDid") > 1000000 {
1033 return xerrors.Errorf("Value in field \"committerDid\" was too long")
1034 }
1035
1036 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("committerDid"))); err != nil {
1037 return err
1038 }
1039 if _, err := cw.WriteString(string("committerDid")); err != nil {
1040 return err
1041 }
1042
1043 if len(t.CommitterDid) > 1000000 {
1044 return xerrors.Errorf("Value in field t.CommitterDid was too long")
1045 }
1046
1047 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CommitterDid))); err != nil {
1048 return err
1049 }
1050 if _, err := cw.WriteString(string(t.CommitterDid)); err != nil {
1051 return err
1052 }
1053 return nil
1054}
1055
1056func (t *GitRefUpdate) UnmarshalCBOR(r io.Reader) (err error) {
1057 *t = GitRefUpdate{}
1058
1059 cr := cbg.NewCborReader(r)
1060
1061 maj, extra, err := cr.ReadHeader()
1062 if err != nil {
1063 return err
1064 }
1065 defer func() {
1066 if err == io.EOF {
1067 err = io.ErrUnexpectedEOF
1068 }
1069 }()
1070
1071 if maj != cbg.MajMap {
1072 return fmt.Errorf("cbor input should be of type map")
1073 }
1074
1075 if extra > cbg.MaxLength {
1076 return fmt.Errorf("GitRefUpdate: map struct too large (%d)", extra)
1077 }
1078
1079 n := extra
1080
1081 nameBuf := make([]byte, 12)
1082 for i := uint64(0); i < n; i++ {
1083 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1084 if err != nil {
1085 return err
1086 }
1087
1088 if !ok {
1089 // Field doesn't exist on this type, so ignore it
1090 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1091 return err
1092 }
1093 continue
1094 }
1095
1096 switch string(nameBuf[:nameLen]) {
1097 // t.Ref (string) (string)
1098 case "ref":
1099
1100 {
1101 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1102 if err != nil {
1103 return err
1104 }
1105
1106 t.Ref = string(sval)
1107 }
1108 // t.Meta (tangled.GitRefUpdate_Meta) (struct)
1109 case "meta":
1110
1111 {
1112
1113 b, err := cr.ReadByte()
1114 if err != nil {
1115 return err
1116 }
1117 if b != cbg.CborNull[0] {
1118 if err := cr.UnreadByte(); err != nil {
1119 return err
1120 }
1121 t.Meta = new(GitRefUpdate_Meta)
1122 if err := t.Meta.UnmarshalCBOR(cr); err != nil {
1123 return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err)
1124 }
1125 }
1126
1127 }
1128 // t.LexiconTypeID (string) (string)
1129 case "$type":
1130
1131 {
1132 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1133 if err != nil {
1134 return err
1135 }
1136
1137 t.LexiconTypeID = string(sval)
1138 }
1139 // t.NewSha (string) (string)
1140 case "newSha":
1141
1142 {
1143 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1144 if err != nil {
1145 return err
1146 }
1147
1148 t.NewSha = string(sval)
1149 }
1150 // t.OldSha (string) (string)
1151 case "oldSha":
1152
1153 {
1154 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1155 if err != nil {
1156 return err
1157 }
1158
1159 t.OldSha = string(sval)
1160 }
1161 // t.RepoDid (string) (string)
1162 case "repoDid":
1163
1164 {
1165 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1166 if err != nil {
1167 return err
1168 }
1169
1170 t.RepoDid = string(sval)
1171 }
1172 // t.RepoName (string) (string)
1173 case "repoName":
1174
1175 {
1176 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1177 if err != nil {
1178 return err
1179 }
1180
1181 t.RepoName = string(sval)
1182 }
1183 // t.CommitterDid (string) (string)
1184 case "committerDid":
1185
1186 {
1187 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1188 if err != nil {
1189 return err
1190 }
1191
1192 t.CommitterDid = string(sval)
1193 }
1194
1195 default:
1196 // Field doesn't exist on this type, so ignore it
1197 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1198 return err
1199 }
1200 }
1201 }
1202
1203 return nil
1204}
1205func (t *GitRefUpdate_CommitCountBreakdown) MarshalCBOR(w io.Writer) error {
1206 if t == nil {
1207 _, err := w.Write(cbg.CborNull)
1208 return err
1209 }
1210
1211 cw := cbg.NewCborWriter(w)
1212 fieldCount := 1
1213
1214 if t.ByEmail == nil {
1215 fieldCount--
1216 }
1217
1218 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1219 return err
1220 }
1221
1222 // t.ByEmail ([]*tangled.GitRefUpdate_IndividualEmailCommitCount) (slice)
1223 if t.ByEmail != nil {
1224
1225 if len("byEmail") > 1000000 {
1226 return xerrors.Errorf("Value in field \"byEmail\" was too long")
1227 }
1228
1229 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byEmail"))); err != nil {
1230 return err
1231 }
1232 if _, err := cw.WriteString(string("byEmail")); err != nil {
1233 return err
1234 }
1235
1236 if len(t.ByEmail) > 8192 {
1237 return xerrors.Errorf("Slice value in field t.ByEmail was too long")
1238 }
1239
1240 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ByEmail))); err != nil {
1241 return err
1242 }
1243 for _, v := range t.ByEmail {
1244 if err := v.MarshalCBOR(cw); err != nil {
1245 return err
1246 }
1247
1248 }
1249 }
1250 return nil
1251}
1252
1253func (t *GitRefUpdate_CommitCountBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
1254 *t = GitRefUpdate_CommitCountBreakdown{}
1255
1256 cr := cbg.NewCborReader(r)
1257
1258 maj, extra, err := cr.ReadHeader()
1259 if err != nil {
1260 return err
1261 }
1262 defer func() {
1263 if err == io.EOF {
1264 err = io.ErrUnexpectedEOF
1265 }
1266 }()
1267
1268 if maj != cbg.MajMap {
1269 return fmt.Errorf("cbor input should be of type map")
1270 }
1271
1272 if extra > cbg.MaxLength {
1273 return fmt.Errorf("GitRefUpdate_CommitCountBreakdown: map struct too large (%d)", extra)
1274 }
1275
1276 n := extra
1277
1278 nameBuf := make([]byte, 7)
1279 for i := uint64(0); i < n; i++ {
1280 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1281 if err != nil {
1282 return err
1283 }
1284
1285 if !ok {
1286 // Field doesn't exist on this type, so ignore it
1287 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1288 return err
1289 }
1290 continue
1291 }
1292
1293 switch string(nameBuf[:nameLen]) {
1294 // t.ByEmail ([]*tangled.GitRefUpdate_IndividualEmailCommitCount) (slice)
1295 case "byEmail":
1296
1297 maj, extra, err = cr.ReadHeader()
1298 if err != nil {
1299 return err
1300 }
1301
1302 if extra > 8192 {
1303 return fmt.Errorf("t.ByEmail: array too large (%d)", extra)
1304 }
1305
1306 if maj != cbg.MajArray {
1307 return fmt.Errorf("expected cbor array")
1308 }
1309
1310 if extra > 0 {
1311 t.ByEmail = make([]*GitRefUpdate_IndividualEmailCommitCount, extra)
1312 }
1313
1314 for i := 0; i < int(extra); i++ {
1315 {
1316 var maj byte
1317 var extra uint64
1318 var err error
1319 _ = maj
1320 _ = extra
1321 _ = err
1322
1323 {
1324
1325 b, err := cr.ReadByte()
1326 if err != nil {
1327 return err
1328 }
1329 if b != cbg.CborNull[0] {
1330 if err := cr.UnreadByte(); err != nil {
1331 return err
1332 }
1333 t.ByEmail[i] = new(GitRefUpdate_IndividualEmailCommitCount)
1334 if err := t.ByEmail[i].UnmarshalCBOR(cr); err != nil {
1335 return xerrors.Errorf("unmarshaling t.ByEmail[i] pointer: %w", err)
1336 }
1337 }
1338
1339 }
1340
1341 }
1342 }
1343
1344 default:
1345 // Field doesn't exist on this type, so ignore it
1346 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1347 return err
1348 }
1349 }
1350 }
1351
1352 return nil
1353}
1354func (t *GitRefUpdate_IndividualEmailCommitCount) MarshalCBOR(w io.Writer) error {
1355 if t == nil {
1356 _, err := w.Write(cbg.CborNull)
1357 return err
1358 }
1359
1360 cw := cbg.NewCborWriter(w)
1361
1362 if _, err := cw.Write([]byte{162}); err != nil {
1363 return err
1364 }
1365
1366 // t.Count (int64) (int64)
1367 if len("count") > 1000000 {
1368 return xerrors.Errorf("Value in field \"count\" was too long")
1369 }
1370
1371 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("count"))); err != nil {
1372 return err
1373 }
1374 if _, err := cw.WriteString(string("count")); err != nil {
1375 return err
1376 }
1377
1378 if t.Count >= 0 {
1379 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Count)); err != nil {
1380 return err
1381 }
1382 } else {
1383 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Count-1)); err != nil {
1384 return err
1385 }
1386 }
1387
1388 // t.Email (string) (string)
1389 if len("email") > 1000000 {
1390 return xerrors.Errorf("Value in field \"email\" was too long")
1391 }
1392
1393 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("email"))); err != nil {
1394 return err
1395 }
1396 if _, err := cw.WriteString(string("email")); err != nil {
1397 return err
1398 }
1399
1400 if len(t.Email) > 1000000 {
1401 return xerrors.Errorf("Value in field t.Email was too long")
1402 }
1403
1404 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Email))); err != nil {
1405 return err
1406 }
1407 if _, err := cw.WriteString(string(t.Email)); err != nil {
1408 return err
1409 }
1410 return nil
1411}
1412
1413func (t *GitRefUpdate_IndividualEmailCommitCount) UnmarshalCBOR(r io.Reader) (err error) {
1414 *t = GitRefUpdate_IndividualEmailCommitCount{}
1415
1416 cr := cbg.NewCborReader(r)
1417
1418 maj, extra, err := cr.ReadHeader()
1419 if err != nil {
1420 return err
1421 }
1422 defer func() {
1423 if err == io.EOF {
1424 err = io.ErrUnexpectedEOF
1425 }
1426 }()
1427
1428 if maj != cbg.MajMap {
1429 return fmt.Errorf("cbor input should be of type map")
1430 }
1431
1432 if extra > cbg.MaxLength {
1433 return fmt.Errorf("GitRefUpdate_IndividualEmailCommitCount: map struct too large (%d)", extra)
1434 }
1435
1436 n := extra
1437
1438 nameBuf := make([]byte, 5)
1439 for i := uint64(0); i < n; i++ {
1440 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1441 if err != nil {
1442 return err
1443 }
1444
1445 if !ok {
1446 // Field doesn't exist on this type, so ignore it
1447 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1448 return err
1449 }
1450 continue
1451 }
1452
1453 switch string(nameBuf[:nameLen]) {
1454 // t.Count (int64) (int64)
1455 case "count":
1456 {
1457 maj, extra, err := cr.ReadHeader()
1458 if err != nil {
1459 return err
1460 }
1461 var extraI int64
1462 switch maj {
1463 case cbg.MajUnsignedInt:
1464 extraI = int64(extra)
1465 if extraI < 0 {
1466 return fmt.Errorf("int64 positive overflow")
1467 }
1468 case cbg.MajNegativeInt:
1469 extraI = int64(extra)
1470 if extraI < 0 {
1471 return fmt.Errorf("int64 negative overflow")
1472 }
1473 extraI = -1 - extraI
1474 default:
1475 return fmt.Errorf("wrong type for int64 field: %d", maj)
1476 }
1477
1478 t.Count = int64(extraI)
1479 }
1480 // t.Email (string) (string)
1481 case "email":
1482
1483 {
1484 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1485 if err != nil {
1486 return err
1487 }
1488
1489 t.Email = string(sval)
1490 }
1491
1492 default:
1493 // Field doesn't exist on this type, so ignore it
1494 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1495 return err
1496 }
1497 }
1498 }
1499
1500 return nil
1501}
1502func (t *GitRefUpdate_IndividualLanguageSize) MarshalCBOR(w io.Writer) error {
1503 if t == nil {
1504 _, err := w.Write(cbg.CborNull)
1505 return err
1506 }
1507
1508 cw := cbg.NewCborWriter(w)
1509
1510 if _, err := cw.Write([]byte{162}); err != nil {
1511 return err
1512 }
1513
1514 // t.Lang (string) (string)
1515 if len("lang") > 1000000 {
1516 return xerrors.Errorf("Value in field \"lang\" was too long")
1517 }
1518
1519 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil {
1520 return err
1521 }
1522 if _, err := cw.WriteString(string("lang")); err != nil {
1523 return err
1524 }
1525
1526 if len(t.Lang) > 1000000 {
1527 return xerrors.Errorf("Value in field t.Lang was too long")
1528 }
1529
1530 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil {
1531 return err
1532 }
1533 if _, err := cw.WriteString(string(t.Lang)); err != nil {
1534 return err
1535 }
1536
1537 // t.Size (int64) (int64)
1538 if len("size") > 1000000 {
1539 return xerrors.Errorf("Value in field \"size\" was too long")
1540 }
1541
1542 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil {
1543 return err
1544 }
1545 if _, err := cw.WriteString(string("size")); err != nil {
1546 return err
1547 }
1548
1549 if t.Size >= 0 {
1550 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil {
1551 return err
1552 }
1553 } else {
1554 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); err != nil {
1555 return err
1556 }
1557 }
1558
1559 return nil
1560}
1561
1562func (t *GitRefUpdate_IndividualLanguageSize) UnmarshalCBOR(r io.Reader) (err error) {
1563 *t = GitRefUpdate_IndividualLanguageSize{}
1564
1565 cr := cbg.NewCborReader(r)
1566
1567 maj, extra, err := cr.ReadHeader()
1568 if err != nil {
1569 return err
1570 }
1571 defer func() {
1572 if err == io.EOF {
1573 err = io.ErrUnexpectedEOF
1574 }
1575 }()
1576
1577 if maj != cbg.MajMap {
1578 return fmt.Errorf("cbor input should be of type map")
1579 }
1580
1581 if extra > cbg.MaxLength {
1582 return fmt.Errorf("GitRefUpdate_IndividualLanguageSize: map struct too large (%d)", extra)
1583 }
1584
1585 n := extra
1586
1587 nameBuf := make([]byte, 4)
1588 for i := uint64(0); i < n; i++ {
1589 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1590 if err != nil {
1591 return err
1592 }
1593
1594 if !ok {
1595 // Field doesn't exist on this type, so ignore it
1596 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1597 return err
1598 }
1599 continue
1600 }
1601
1602 switch string(nameBuf[:nameLen]) {
1603 // t.Lang (string) (string)
1604 case "lang":
1605
1606 {
1607 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1608 if err != nil {
1609 return err
1610 }
1611
1612 t.Lang = string(sval)
1613 }
1614 // t.Size (int64) (int64)
1615 case "size":
1616 {
1617 maj, extra, err := cr.ReadHeader()
1618 if err != nil {
1619 return err
1620 }
1621 var extraI int64
1622 switch maj {
1623 case cbg.MajUnsignedInt:
1624 extraI = int64(extra)
1625 if extraI < 0 {
1626 return fmt.Errorf("int64 positive overflow")
1627 }
1628 case cbg.MajNegativeInt:
1629 extraI = int64(extra)
1630 if extraI < 0 {
1631 return fmt.Errorf("int64 negative overflow")
1632 }
1633 extraI = -1 - extraI
1634 default:
1635 return fmt.Errorf("wrong type for int64 field: %d", maj)
1636 }
1637
1638 t.Size = int64(extraI)
1639 }
1640
1641 default:
1642 // Field doesn't exist on this type, so ignore it
1643 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1644 return err
1645 }
1646 }
1647 }
1648
1649 return nil
1650}
1651func (t *GitRefUpdate_LangBreakdown) MarshalCBOR(w io.Writer) error {
1652 if t == nil {
1653 _, err := w.Write(cbg.CborNull)
1654 return err
1655 }
1656
1657 cw := cbg.NewCborWriter(w)
1658 fieldCount := 1
1659
1660 if t.Inputs == nil {
1661 fieldCount--
1662 }
1663
1664 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1665 return err
1666 }
1667
1668 // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice)
1669 if t.Inputs != nil {
1670
1671 if len("inputs") > 1000000 {
1672 return xerrors.Errorf("Value in field \"inputs\" was too long")
1673 }
1674
1675 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
1676 return err
1677 }
1678 if _, err := cw.WriteString(string("inputs")); err != nil {
1679 return err
1680 }
1681
1682 if len(t.Inputs) > 8192 {
1683 return xerrors.Errorf("Slice value in field t.Inputs was too long")
1684 }
1685
1686 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
1687 return err
1688 }
1689 for _, v := range t.Inputs {
1690 if err := v.MarshalCBOR(cw); err != nil {
1691 return err
1692 }
1693
1694 }
1695 }
1696 return nil
1697}
1698
1699func (t *GitRefUpdate_LangBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
1700 *t = GitRefUpdate_LangBreakdown{}
1701
1702 cr := cbg.NewCborReader(r)
1703
1704 maj, extra, err := cr.ReadHeader()
1705 if err != nil {
1706 return err
1707 }
1708 defer func() {
1709 if err == io.EOF {
1710 err = io.ErrUnexpectedEOF
1711 }
1712 }()
1713
1714 if maj != cbg.MajMap {
1715 return fmt.Errorf("cbor input should be of type map")
1716 }
1717
1718 if extra > cbg.MaxLength {
1719 return fmt.Errorf("GitRefUpdate_LangBreakdown: map struct too large (%d)", extra)
1720 }
1721
1722 n := extra
1723
1724 nameBuf := make([]byte, 6)
1725 for i := uint64(0); i < n; i++ {
1726 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1727 if err != nil {
1728 return err
1729 }
1730
1731 if !ok {
1732 // Field doesn't exist on this type, so ignore it
1733 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1734 return err
1735 }
1736 continue
1737 }
1738
1739 switch string(nameBuf[:nameLen]) {
1740 // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice)
1741 case "inputs":
1742
1743 maj, extra, err = cr.ReadHeader()
1744 if err != nil {
1745 return err
1746 }
1747
1748 if extra > 8192 {
1749 return fmt.Errorf("t.Inputs: array too large (%d)", extra)
1750 }
1751
1752 if maj != cbg.MajArray {
1753 return fmt.Errorf("expected cbor array")
1754 }
1755
1756 if extra > 0 {
1757 t.Inputs = make([]*GitRefUpdate_IndividualLanguageSize, extra)
1758 }
1759
1760 for i := 0; i < int(extra); i++ {
1761 {
1762 var maj byte
1763 var extra uint64
1764 var err error
1765 _ = maj
1766 _ = extra
1767 _ = err
1768
1769 {
1770
1771 b, err := cr.ReadByte()
1772 if err != nil {
1773 return err
1774 }
1775 if b != cbg.CborNull[0] {
1776 if err := cr.UnreadByte(); err != nil {
1777 return err
1778 }
1779 t.Inputs[i] = new(GitRefUpdate_IndividualLanguageSize)
1780 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
1781 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
1782 }
1783 }
1784
1785 }
1786
1787 }
1788 }
1789
1790 default:
1791 // Field doesn't exist on this type, so ignore it
1792 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1793 return err
1794 }
1795 }
1796 }
1797
1798 return nil
1799}
1800func (t *GitRefUpdate_Meta) MarshalCBOR(w io.Writer) error {
1801 if t == nil {
1802 _, err := w.Write(cbg.CborNull)
1803 return err
1804 }
1805
1806 cw := cbg.NewCborWriter(w)
1807 fieldCount := 3
1808
1809 if t.LangBreakdown == nil {
1810 fieldCount--
1811 }
1812
1813 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1814 return err
1815 }
1816
1817 // t.CommitCount (tangled.GitRefUpdate_CommitCountBreakdown) (struct)
1818 if len("commitCount") > 1000000 {
1819 return xerrors.Errorf("Value in field \"commitCount\" was too long")
1820 }
1821
1822 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commitCount"))); err != nil {
1823 return err
1824 }
1825 if _, err := cw.WriteString(string("commitCount")); err != nil {
1826 return err
1827 }
1828
1829 if err := t.CommitCount.MarshalCBOR(cw); err != nil {
1830 return err
1831 }
1832
1833 // t.IsDefaultRef (bool) (bool)
1834 if len("isDefaultRef") > 1000000 {
1835 return xerrors.Errorf("Value in field \"isDefaultRef\" was too long")
1836 }
1837
1838 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("isDefaultRef"))); err != nil {
1839 return err
1840 }
1841 if _, err := cw.WriteString(string("isDefaultRef")); err != nil {
1842 return err
1843 }
1844
1845 if err := cbg.WriteBool(w, t.IsDefaultRef); err != nil {
1846 return err
1847 }
1848
1849 // t.LangBreakdown (tangled.GitRefUpdate_LangBreakdown) (struct)
1850 if t.LangBreakdown != nil {
1851
1852 if len("langBreakdown") > 1000000 {
1853 return xerrors.Errorf("Value in field \"langBreakdown\" was too long")
1854 }
1855
1856 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("langBreakdown"))); err != nil {
1857 return err
1858 }
1859 if _, err := cw.WriteString(string("langBreakdown")); err != nil {
1860 return err
1861 }
1862
1863 if err := t.LangBreakdown.MarshalCBOR(cw); err != nil {
1864 return err
1865 }
1866 }
1867 return nil
1868}
1869
1870func (t *GitRefUpdate_Meta) UnmarshalCBOR(r io.Reader) (err error) {
1871 *t = GitRefUpdate_Meta{}
1872
1873 cr := cbg.NewCborReader(r)
1874
1875 maj, extra, err := cr.ReadHeader()
1876 if err != nil {
1877 return err
1878 }
1879 defer func() {
1880 if err == io.EOF {
1881 err = io.ErrUnexpectedEOF
1882 }
1883 }()
1884
1885 if maj != cbg.MajMap {
1886 return fmt.Errorf("cbor input should be of type map")
1887 }
1888
1889 if extra > cbg.MaxLength {
1890 return fmt.Errorf("GitRefUpdate_Meta: map struct too large (%d)", extra)
1891 }
1892
1893 n := extra
1894
1895 nameBuf := make([]byte, 13)
1896 for i := uint64(0); i < n; i++ {
1897 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1898 if err != nil {
1899 return err
1900 }
1901
1902 if !ok {
1903 // Field doesn't exist on this type, so ignore it
1904 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1905 return err
1906 }
1907 continue
1908 }
1909
1910 switch string(nameBuf[:nameLen]) {
1911 // t.CommitCount (tangled.GitRefUpdate_CommitCountBreakdown) (struct)
1912 case "commitCount":
1913
1914 {
1915
1916 b, err := cr.ReadByte()
1917 if err != nil {
1918 return err
1919 }
1920 if b != cbg.CborNull[0] {
1921 if err := cr.UnreadByte(); err != nil {
1922 return err
1923 }
1924 t.CommitCount = new(GitRefUpdate_CommitCountBreakdown)
1925 if err := t.CommitCount.UnmarshalCBOR(cr); err != nil {
1926 return xerrors.Errorf("unmarshaling t.CommitCount pointer: %w", err)
1927 }
1928 }
1929
1930 }
1931 // t.IsDefaultRef (bool) (bool)
1932 case "isDefaultRef":
1933
1934 maj, extra, err = cr.ReadHeader()
1935 if err != nil {
1936 return err
1937 }
1938 if maj != cbg.MajOther {
1939 return fmt.Errorf("booleans must be major type 7")
1940 }
1941 switch extra {
1942 case 20:
1943 t.IsDefaultRef = false
1944 case 21:
1945 t.IsDefaultRef = true
1946 default:
1947 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
1948 }
1949 // t.LangBreakdown (tangled.GitRefUpdate_LangBreakdown) (struct)
1950 case "langBreakdown":
1951
1952 {
1953
1954 b, err := cr.ReadByte()
1955 if err != nil {
1956 return err
1957 }
1958 if b != cbg.CborNull[0] {
1959 if err := cr.UnreadByte(); err != nil {
1960 return err
1961 }
1962 t.LangBreakdown = new(GitRefUpdate_LangBreakdown)
1963 if err := t.LangBreakdown.UnmarshalCBOR(cr); err != nil {
1964 return xerrors.Errorf("unmarshaling t.LangBreakdown pointer: %w", err)
1965 }
1966 }
1967
1968 }
1969
1970 default:
1971 // Field doesn't exist on this type, so ignore it
1972 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1973 return err
1974 }
1975 }
1976 }
1977
1978 return nil
1979}
1980func (t *GraphFollow) MarshalCBOR(w io.Writer) error {
1981 if t == nil {
1982 _, err := w.Write(cbg.CborNull)
1983 return err
1984 }
1985
1986 cw := cbg.NewCborWriter(w)
1987
1988 if _, err := cw.Write([]byte{163}); err != nil {
1989 return err
1990 }
1991
1992 // t.LexiconTypeID (string) (string)
1993 if len("$type") > 1000000 {
1994 return xerrors.Errorf("Value in field \"$type\" was too long")
1995 }
1996
1997 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
1998 return err
1999 }
2000 if _, err := cw.WriteString(string("$type")); err != nil {
2001 return err
2002 }
2003
2004 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.graph.follow"))); err != nil {
2005 return err
2006 }
2007 if _, err := cw.WriteString(string("sh.tangled.graph.follow")); err != nil {
2008 return err
2009 }
2010
2011 // t.Subject (string) (string)
2012 if len("subject") > 1000000 {
2013 return xerrors.Errorf("Value in field \"subject\" was too long")
2014 }
2015
2016 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
2017 return err
2018 }
2019 if _, err := cw.WriteString(string("subject")); err != nil {
2020 return err
2021 }
2022
2023 if len(t.Subject) > 1000000 {
2024 return xerrors.Errorf("Value in field t.Subject was too long")
2025 }
2026
2027 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
2028 return err
2029 }
2030 if _, err := cw.WriteString(string(t.Subject)); err != nil {
2031 return err
2032 }
2033
2034 // t.CreatedAt (string) (string)
2035 if len("createdAt") > 1000000 {
2036 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2037 }
2038
2039 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2040 return err
2041 }
2042 if _, err := cw.WriteString(string("createdAt")); err != nil {
2043 return err
2044 }
2045
2046 if len(t.CreatedAt) > 1000000 {
2047 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2048 }
2049
2050 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2051 return err
2052 }
2053 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2054 return err
2055 }
2056 return nil
2057}
2058
2059func (t *GraphFollow) UnmarshalCBOR(r io.Reader) (err error) {
2060 *t = GraphFollow{}
2061
2062 cr := cbg.NewCborReader(r)
2063
2064 maj, extra, err := cr.ReadHeader()
2065 if err != nil {
2066 return err
2067 }
2068 defer func() {
2069 if err == io.EOF {
2070 err = io.ErrUnexpectedEOF
2071 }
2072 }()
2073
2074 if maj != cbg.MajMap {
2075 return fmt.Errorf("cbor input should be of type map")
2076 }
2077
2078 if extra > cbg.MaxLength {
2079 return fmt.Errorf("GraphFollow: map struct too large (%d)", extra)
2080 }
2081
2082 n := extra
2083
2084 nameBuf := make([]byte, 9)
2085 for i := uint64(0); i < n; i++ {
2086 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2087 if err != nil {
2088 return err
2089 }
2090
2091 if !ok {
2092 // Field doesn't exist on this type, so ignore it
2093 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2094 return err
2095 }
2096 continue
2097 }
2098
2099 switch string(nameBuf[:nameLen]) {
2100 // t.LexiconTypeID (string) (string)
2101 case "$type":
2102
2103 {
2104 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2105 if err != nil {
2106 return err
2107 }
2108
2109 t.LexiconTypeID = string(sval)
2110 }
2111 // t.Subject (string) (string)
2112 case "subject":
2113
2114 {
2115 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2116 if err != nil {
2117 return err
2118 }
2119
2120 t.Subject = string(sval)
2121 }
2122 // t.CreatedAt (string) (string)
2123 case "createdAt":
2124
2125 {
2126 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2127 if err != nil {
2128 return err
2129 }
2130
2131 t.CreatedAt = string(sval)
2132 }
2133
2134 default:
2135 // Field doesn't exist on this type, so ignore it
2136 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2137 return err
2138 }
2139 }
2140 }
2141
2142 return nil
2143}
2144func (t *Knot) MarshalCBOR(w io.Writer) error {
2145 if t == nil {
2146 _, err := w.Write(cbg.CborNull)
2147 return err
2148 }
2149
2150 cw := cbg.NewCborWriter(w)
2151
2152 if _, err := cw.Write([]byte{162}); err != nil {
2153 return err
2154 }
2155
2156 // t.LexiconTypeID (string) (string)
2157 if len("$type") > 1000000 {
2158 return xerrors.Errorf("Value in field \"$type\" was too long")
2159 }
2160
2161 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2162 return err
2163 }
2164 if _, err := cw.WriteString(string("$type")); err != nil {
2165 return err
2166 }
2167
2168 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot"))); err != nil {
2169 return err
2170 }
2171 if _, err := cw.WriteString(string("sh.tangled.knot")); err != nil {
2172 return err
2173 }
2174
2175 // t.CreatedAt (string) (string)
2176 if len("createdAt") > 1000000 {
2177 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2178 }
2179
2180 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2181 return err
2182 }
2183 if _, err := cw.WriteString(string("createdAt")); err != nil {
2184 return err
2185 }
2186
2187 if len(t.CreatedAt) > 1000000 {
2188 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2189 }
2190
2191 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2192 return err
2193 }
2194 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2195 return err
2196 }
2197 return nil
2198}
2199
2200func (t *Knot) UnmarshalCBOR(r io.Reader) (err error) {
2201 *t = Knot{}
2202
2203 cr := cbg.NewCborReader(r)
2204
2205 maj, extra, err := cr.ReadHeader()
2206 if err != nil {
2207 return err
2208 }
2209 defer func() {
2210 if err == io.EOF {
2211 err = io.ErrUnexpectedEOF
2212 }
2213 }()
2214
2215 if maj != cbg.MajMap {
2216 return fmt.Errorf("cbor input should be of type map")
2217 }
2218
2219 if extra > cbg.MaxLength {
2220 return fmt.Errorf("Knot: map struct too large (%d)", extra)
2221 }
2222
2223 n := extra
2224
2225 nameBuf := make([]byte, 9)
2226 for i := uint64(0); i < n; i++ {
2227 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2228 if err != nil {
2229 return err
2230 }
2231
2232 if !ok {
2233 // Field doesn't exist on this type, so ignore it
2234 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2235 return err
2236 }
2237 continue
2238 }
2239
2240 switch string(nameBuf[:nameLen]) {
2241 // t.LexiconTypeID (string) (string)
2242 case "$type":
2243
2244 {
2245 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2246 if err != nil {
2247 return err
2248 }
2249
2250 t.LexiconTypeID = string(sval)
2251 }
2252 // t.CreatedAt (string) (string)
2253 case "createdAt":
2254
2255 {
2256 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2257 if err != nil {
2258 return err
2259 }
2260
2261 t.CreatedAt = string(sval)
2262 }
2263
2264 default:
2265 // Field doesn't exist on this type, so ignore it
2266 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2267 return err
2268 }
2269 }
2270 }
2271
2272 return nil
2273}
2274func (t *KnotMember) MarshalCBOR(w io.Writer) error {
2275 if t == nil {
2276 _, err := w.Write(cbg.CborNull)
2277 return err
2278 }
2279
2280 cw := cbg.NewCborWriter(w)
2281
2282 if _, err := cw.Write([]byte{164}); err != nil {
2283 return err
2284 }
2285
2286 // t.LexiconTypeID (string) (string)
2287 if len("$type") > 1000000 {
2288 return xerrors.Errorf("Value in field \"$type\" was too long")
2289 }
2290
2291 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2292 return err
2293 }
2294 if _, err := cw.WriteString(string("$type")); err != nil {
2295 return err
2296 }
2297
2298 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot.member"))); err != nil {
2299 return err
2300 }
2301 if _, err := cw.WriteString(string("sh.tangled.knot.member")); err != nil {
2302 return err
2303 }
2304
2305 // t.Domain (string) (string)
2306 if len("domain") > 1000000 {
2307 return xerrors.Errorf("Value in field \"domain\" was too long")
2308 }
2309
2310 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("domain"))); err != nil {
2311 return err
2312 }
2313 if _, err := cw.WriteString(string("domain")); err != nil {
2314 return err
2315 }
2316
2317 if len(t.Domain) > 1000000 {
2318 return xerrors.Errorf("Value in field t.Domain was too long")
2319 }
2320
2321 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Domain))); err != nil {
2322 return err
2323 }
2324 if _, err := cw.WriteString(string(t.Domain)); err != nil {
2325 return err
2326 }
2327
2328 // t.Subject (string) (string)
2329 if len("subject") > 1000000 {
2330 return xerrors.Errorf("Value in field \"subject\" was too long")
2331 }
2332
2333 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
2334 return err
2335 }
2336 if _, err := cw.WriteString(string("subject")); err != nil {
2337 return err
2338 }
2339
2340 if len(t.Subject) > 1000000 {
2341 return xerrors.Errorf("Value in field t.Subject was too long")
2342 }
2343
2344 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
2345 return err
2346 }
2347 if _, err := cw.WriteString(string(t.Subject)); err != nil {
2348 return err
2349 }
2350
2351 // t.CreatedAt (string) (string)
2352 if len("createdAt") > 1000000 {
2353 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2354 }
2355
2356 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2357 return err
2358 }
2359 if _, err := cw.WriteString(string("createdAt")); err != nil {
2360 return err
2361 }
2362
2363 if len(t.CreatedAt) > 1000000 {
2364 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2365 }
2366
2367 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2368 return err
2369 }
2370 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2371 return err
2372 }
2373 return nil
2374}
2375
2376func (t *KnotMember) UnmarshalCBOR(r io.Reader) (err error) {
2377 *t = KnotMember{}
2378
2379 cr := cbg.NewCborReader(r)
2380
2381 maj, extra, err := cr.ReadHeader()
2382 if err != nil {
2383 return err
2384 }
2385 defer func() {
2386 if err == io.EOF {
2387 err = io.ErrUnexpectedEOF
2388 }
2389 }()
2390
2391 if maj != cbg.MajMap {
2392 return fmt.Errorf("cbor input should be of type map")
2393 }
2394
2395 if extra > cbg.MaxLength {
2396 return fmt.Errorf("KnotMember: map struct too large (%d)", extra)
2397 }
2398
2399 n := extra
2400
2401 nameBuf := make([]byte, 9)
2402 for i := uint64(0); i < n; i++ {
2403 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2404 if err != nil {
2405 return err
2406 }
2407
2408 if !ok {
2409 // Field doesn't exist on this type, so ignore it
2410 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2411 return err
2412 }
2413 continue
2414 }
2415
2416 switch string(nameBuf[:nameLen]) {
2417 // t.LexiconTypeID (string) (string)
2418 case "$type":
2419
2420 {
2421 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2422 if err != nil {
2423 return err
2424 }
2425
2426 t.LexiconTypeID = string(sval)
2427 }
2428 // t.Domain (string) (string)
2429 case "domain":
2430
2431 {
2432 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2433 if err != nil {
2434 return err
2435 }
2436
2437 t.Domain = string(sval)
2438 }
2439 // t.Subject (string) (string)
2440 case "subject":
2441
2442 {
2443 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2444 if err != nil {
2445 return err
2446 }
2447
2448 t.Subject = string(sval)
2449 }
2450 // t.CreatedAt (string) (string)
2451 case "createdAt":
2452
2453 {
2454 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2455 if err != nil {
2456 return err
2457 }
2458
2459 t.CreatedAt = string(sval)
2460 }
2461
2462 default:
2463 // Field doesn't exist on this type, so ignore it
2464 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2465 return err
2466 }
2467 }
2468 }
2469
2470 return nil
2471}
2472func (t *LabelDefinition) MarshalCBOR(w io.Writer) error {
2473 if t == nil {
2474 _, err := w.Write(cbg.CborNull)
2475 return err
2476 }
2477
2478 cw := cbg.NewCborWriter(w)
2479 fieldCount := 7
2480
2481 if t.Color == nil {
2482 fieldCount--
2483 }
2484
2485 if t.Multiple == nil {
2486 fieldCount--
2487 }
2488
2489 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2490 return err
2491 }
2492
2493 // t.Name (string) (string)
2494 if len("name") > 1000000 {
2495 return xerrors.Errorf("Value in field \"name\" was too long")
2496 }
2497
2498 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
2499 return err
2500 }
2501 if _, err := cw.WriteString(string("name")); err != nil {
2502 return err
2503 }
2504
2505 if len(t.Name) > 1000000 {
2506 return xerrors.Errorf("Value in field t.Name was too long")
2507 }
2508
2509 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
2510 return err
2511 }
2512 if _, err := cw.WriteString(string(t.Name)); err != nil {
2513 return err
2514 }
2515
2516 // t.LexiconTypeID (string) (string)
2517 if len("$type") > 1000000 {
2518 return xerrors.Errorf("Value in field \"$type\" was too long")
2519 }
2520
2521 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2522 return err
2523 }
2524 if _, err := cw.WriteString(string("$type")); err != nil {
2525 return err
2526 }
2527
2528 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.definition"))); err != nil {
2529 return err
2530 }
2531 if _, err := cw.WriteString(string("sh.tangled.label.definition")); err != nil {
2532 return err
2533 }
2534
2535 // t.Color (string) (string)
2536 if t.Color != nil {
2537
2538 if len("color") > 1000000 {
2539 return xerrors.Errorf("Value in field \"color\" was too long")
2540 }
2541
2542 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("color"))); err != nil {
2543 return err
2544 }
2545 if _, err := cw.WriteString(string("color")); err != nil {
2546 return err
2547 }
2548
2549 if t.Color == nil {
2550 if _, err := cw.Write(cbg.CborNull); err != nil {
2551 return err
2552 }
2553 } else {
2554 if len(*t.Color) > 1000000 {
2555 return xerrors.Errorf("Value in field t.Color was too long")
2556 }
2557
2558 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Color))); err != nil {
2559 return err
2560 }
2561 if _, err := cw.WriteString(string(*t.Color)); err != nil {
2562 return err
2563 }
2564 }
2565 }
2566
2567 // t.Scope (string) (string)
2568 if len("scope") > 1000000 {
2569 return xerrors.Errorf("Value in field \"scope\" was too long")
2570 }
2571
2572 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("scope"))); err != nil {
2573 return err
2574 }
2575 if _, err := cw.WriteString(string("scope")); err != nil {
2576 return err
2577 }
2578
2579 if len(t.Scope) > 1000000 {
2580 return xerrors.Errorf("Value in field t.Scope was too long")
2581 }
2582
2583 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Scope))); err != nil {
2584 return err
2585 }
2586 if _, err := cw.WriteString(string(t.Scope)); err != nil {
2587 return err
2588 }
2589
2590 // t.Multiple (bool) (bool)
2591 if t.Multiple != nil {
2592
2593 if len("multiple") > 1000000 {
2594 return xerrors.Errorf("Value in field \"multiple\" was too long")
2595 }
2596
2597 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("multiple"))); err != nil {
2598 return err
2599 }
2600 if _, err := cw.WriteString(string("multiple")); err != nil {
2601 return err
2602 }
2603
2604 if t.Multiple == nil {
2605 if _, err := cw.Write(cbg.CborNull); err != nil {
2606 return err
2607 }
2608 } else {
2609 if err := cbg.WriteBool(w, *t.Multiple); err != nil {
2610 return err
2611 }
2612 }
2613 }
2614
2615 // t.CreatedAt (string) (string)
2616 if len("createdAt") > 1000000 {
2617 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2618 }
2619
2620 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2621 return err
2622 }
2623 if _, err := cw.WriteString(string("createdAt")); err != nil {
2624 return err
2625 }
2626
2627 if len(t.CreatedAt) > 1000000 {
2628 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2629 }
2630
2631 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2632 return err
2633 }
2634 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2635 return err
2636 }
2637
2638 // t.ValueType (tangled.LabelDefinition_ValueType) (struct)
2639 if len("valueType") > 1000000 {
2640 return xerrors.Errorf("Value in field \"valueType\" was too long")
2641 }
2642
2643 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("valueType"))); err != nil {
2644 return err
2645 }
2646 if _, err := cw.WriteString(string("valueType")); err != nil {
2647 return err
2648 }
2649
2650 if err := t.ValueType.MarshalCBOR(cw); err != nil {
2651 return err
2652 }
2653 return nil
2654}
2655
2656func (t *LabelDefinition) UnmarshalCBOR(r io.Reader) (err error) {
2657 *t = LabelDefinition{}
2658
2659 cr := cbg.NewCborReader(r)
2660
2661 maj, extra, err := cr.ReadHeader()
2662 if err != nil {
2663 return err
2664 }
2665 defer func() {
2666 if err == io.EOF {
2667 err = io.ErrUnexpectedEOF
2668 }
2669 }()
2670
2671 if maj != cbg.MajMap {
2672 return fmt.Errorf("cbor input should be of type map")
2673 }
2674
2675 if extra > cbg.MaxLength {
2676 return fmt.Errorf("LabelDefinition: map struct too large (%d)", extra)
2677 }
2678
2679 n := extra
2680
2681 nameBuf := make([]byte, 9)
2682 for i := uint64(0); i < n; i++ {
2683 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2684 if err != nil {
2685 return err
2686 }
2687
2688 if !ok {
2689 // Field doesn't exist on this type, so ignore it
2690 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2691 return err
2692 }
2693 continue
2694 }
2695
2696 switch string(nameBuf[:nameLen]) {
2697 // t.Name (string) (string)
2698 case "name":
2699
2700 {
2701 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2702 if err != nil {
2703 return err
2704 }
2705
2706 t.Name = string(sval)
2707 }
2708 // t.LexiconTypeID (string) (string)
2709 case "$type":
2710
2711 {
2712 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2713 if err != nil {
2714 return err
2715 }
2716
2717 t.LexiconTypeID = string(sval)
2718 }
2719 // t.Color (string) (string)
2720 case "color":
2721
2722 {
2723 b, err := cr.ReadByte()
2724 if err != nil {
2725 return err
2726 }
2727 if b != cbg.CborNull[0] {
2728 if err := cr.UnreadByte(); err != nil {
2729 return err
2730 }
2731
2732 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2733 if err != nil {
2734 return err
2735 }
2736
2737 t.Color = (*string)(&sval)
2738 }
2739 }
2740 // t.Scope (string) (string)
2741 case "scope":
2742
2743 {
2744 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2745 if err != nil {
2746 return err
2747 }
2748
2749 t.Scope = string(sval)
2750 }
2751 // t.Multiple (bool) (bool)
2752 case "multiple":
2753
2754 {
2755 b, err := cr.ReadByte()
2756 if err != nil {
2757 return err
2758 }
2759 if b != cbg.CborNull[0] {
2760 if err := cr.UnreadByte(); err != nil {
2761 return err
2762 }
2763
2764 maj, extra, err = cr.ReadHeader()
2765 if err != nil {
2766 return err
2767 }
2768 if maj != cbg.MajOther {
2769 return fmt.Errorf("booleans must be major type 7")
2770 }
2771
2772 var val bool
2773 switch extra {
2774 case 20:
2775 val = false
2776 case 21:
2777 val = true
2778 default:
2779 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
2780 }
2781 t.Multiple = &val
2782 }
2783 }
2784 // t.CreatedAt (string) (string)
2785 case "createdAt":
2786
2787 {
2788 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2789 if err != nil {
2790 return err
2791 }
2792
2793 t.CreatedAt = string(sval)
2794 }
2795 // t.ValueType (tangled.LabelDefinition_ValueType) (struct)
2796 case "valueType":
2797
2798 {
2799
2800 b, err := cr.ReadByte()
2801 if err != nil {
2802 return err
2803 }
2804 if b != cbg.CborNull[0] {
2805 if err := cr.UnreadByte(); err != nil {
2806 return err
2807 }
2808 t.ValueType = new(LabelDefinition_ValueType)
2809 if err := t.ValueType.UnmarshalCBOR(cr); err != nil {
2810 return xerrors.Errorf("unmarshaling t.ValueType pointer: %w", err)
2811 }
2812 }
2813
2814 }
2815
2816 default:
2817 // Field doesn't exist on this type, so ignore it
2818 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2819 return err
2820 }
2821 }
2822 }
2823
2824 return nil
2825}
2826func (t *LabelDefinition_ValueType) MarshalCBOR(w io.Writer) error {
2827 if t == nil {
2828 _, err := w.Write(cbg.CborNull)
2829 return err
2830 }
2831
2832 cw := cbg.NewCborWriter(w)
2833 fieldCount := 4
2834
2835 if t.Enum == nil {
2836 fieldCount--
2837 }
2838
2839 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2840 return err
2841 }
2842
2843 // t.Enum ([]string) (slice)
2844 if t.Enum != nil {
2845
2846 if len("enum") > 1000000 {
2847 return xerrors.Errorf("Value in field \"enum\" was too long")
2848 }
2849
2850 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("enum"))); err != nil {
2851 return err
2852 }
2853 if _, err := cw.WriteString(string("enum")); err != nil {
2854 return err
2855 }
2856
2857 if len(t.Enum) > 8192 {
2858 return xerrors.Errorf("Slice value in field t.Enum was too long")
2859 }
2860
2861 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Enum))); err != nil {
2862 return err
2863 }
2864 for _, v := range t.Enum {
2865 if len(v) > 1000000 {
2866 return xerrors.Errorf("Value in field v was too long")
2867 }
2868
2869 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
2870 return err
2871 }
2872 if _, err := cw.WriteString(string(v)); err != nil {
2873 return err
2874 }
2875
2876 }
2877 }
2878
2879 // t.Type (string) (string)
2880 if len("type") > 1000000 {
2881 return xerrors.Errorf("Value in field \"type\" was too long")
2882 }
2883
2884 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("type"))); err != nil {
2885 return err
2886 }
2887 if _, err := cw.WriteString(string("type")); err != nil {
2888 return err
2889 }
2890
2891 if len(t.Type) > 1000000 {
2892 return xerrors.Errorf("Value in field t.Type was too long")
2893 }
2894
2895 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Type))); err != nil {
2896 return err
2897 }
2898 if _, err := cw.WriteString(string(t.Type)); err != nil {
2899 return err
2900 }
2901
2902 // t.LexiconTypeID (string) (string)
2903 if len("$type") > 1000000 {
2904 return xerrors.Errorf("Value in field \"$type\" was too long")
2905 }
2906
2907 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2908 return err
2909 }
2910 if _, err := cw.WriteString(string("$type")); err != nil {
2911 return err
2912 }
2913
2914 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.definition"))); err != nil {
2915 return err
2916 }
2917 if _, err := cw.WriteString(string("sh.tangled.label.definition")); err != nil {
2918 return err
2919 }
2920
2921 // t.Format (string) (string)
2922 if len("format") > 1000000 {
2923 return xerrors.Errorf("Value in field \"format\" was too long")
2924 }
2925
2926 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("format"))); err != nil {
2927 return err
2928 }
2929 if _, err := cw.WriteString(string("format")); err != nil {
2930 return err
2931 }
2932
2933 if len(t.Format) > 1000000 {
2934 return xerrors.Errorf("Value in field t.Format was too long")
2935 }
2936
2937 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Format))); err != nil {
2938 return err
2939 }
2940 if _, err := cw.WriteString(string(t.Format)); err != nil {
2941 return err
2942 }
2943 return nil
2944}
2945
2946func (t *LabelDefinition_ValueType) UnmarshalCBOR(r io.Reader) (err error) {
2947 *t = LabelDefinition_ValueType{}
2948
2949 cr := cbg.NewCborReader(r)
2950
2951 maj, extra, err := cr.ReadHeader()
2952 if err != nil {
2953 return err
2954 }
2955 defer func() {
2956 if err == io.EOF {
2957 err = io.ErrUnexpectedEOF
2958 }
2959 }()
2960
2961 if maj != cbg.MajMap {
2962 return fmt.Errorf("cbor input should be of type map")
2963 }
2964
2965 if extra > cbg.MaxLength {
2966 return fmt.Errorf("LabelDefinition_ValueType: map struct too large (%d)", extra)
2967 }
2968
2969 n := extra
2970
2971 nameBuf := make([]byte, 6)
2972 for i := uint64(0); i < n; i++ {
2973 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2974 if err != nil {
2975 return err
2976 }
2977
2978 if !ok {
2979 // Field doesn't exist on this type, so ignore it
2980 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2981 return err
2982 }
2983 continue
2984 }
2985
2986 switch string(nameBuf[:nameLen]) {
2987 // t.Enum ([]string) (slice)
2988 case "enum":
2989
2990 maj, extra, err = cr.ReadHeader()
2991 if err != nil {
2992 return err
2993 }
2994
2995 if extra > 8192 {
2996 return fmt.Errorf("t.Enum: array too large (%d)", extra)
2997 }
2998
2999 if maj != cbg.MajArray {
3000 return fmt.Errorf("expected cbor array")
3001 }
3002
3003 if extra > 0 {
3004 t.Enum = make([]string, extra)
3005 }
3006
3007 for i := 0; i < int(extra); i++ {
3008 {
3009 var maj byte
3010 var extra uint64
3011 var err error
3012 _ = maj
3013 _ = extra
3014 _ = err
3015
3016 {
3017 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3018 if err != nil {
3019 return err
3020 }
3021
3022 t.Enum[i] = string(sval)
3023 }
3024
3025 }
3026 }
3027 // t.Type (string) (string)
3028 case "type":
3029
3030 {
3031 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3032 if err != nil {
3033 return err
3034 }
3035
3036 t.Type = string(sval)
3037 }
3038 // t.LexiconTypeID (string) (string)
3039 case "$type":
3040
3041 {
3042 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3043 if err != nil {
3044 return err
3045 }
3046
3047 t.LexiconTypeID = string(sval)
3048 }
3049 // t.Format (string) (string)
3050 case "format":
3051
3052 {
3053 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3054 if err != nil {
3055 return err
3056 }
3057
3058 t.Format = string(sval)
3059 }
3060
3061 default:
3062 // Field doesn't exist on this type, so ignore it
3063 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3064 return err
3065 }
3066 }
3067 }
3068
3069 return nil
3070}
3071func (t *LabelOp) MarshalCBOR(w io.Writer) error {
3072 if t == nil {
3073 _, err := w.Write(cbg.CborNull)
3074 return err
3075 }
3076
3077 cw := cbg.NewCborWriter(w)
3078
3079 if _, err := cw.Write([]byte{165}); err != nil {
3080 return err
3081 }
3082
3083 // t.Add ([]*tangled.LabelOp_Operand) (slice)
3084 if len("add") > 1000000 {
3085 return xerrors.Errorf("Value in field \"add\" was too long")
3086 }
3087
3088 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("add"))); err != nil {
3089 return err
3090 }
3091 if _, err := cw.WriteString(string("add")); err != nil {
3092 return err
3093 }
3094
3095 if len(t.Add) > 8192 {
3096 return xerrors.Errorf("Slice value in field t.Add was too long")
3097 }
3098
3099 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Add))); err != nil {
3100 return err
3101 }
3102 for _, v := range t.Add {
3103 if err := v.MarshalCBOR(cw); err != nil {
3104 return err
3105 }
3106
3107 }
3108
3109 // t.LexiconTypeID (string) (string)
3110 if len("$type") > 1000000 {
3111 return xerrors.Errorf("Value in field \"$type\" was too long")
3112 }
3113
3114 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3115 return err
3116 }
3117 if _, err := cw.WriteString(string("$type")); err != nil {
3118 return err
3119 }
3120
3121 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.op"))); err != nil {
3122 return err
3123 }
3124 if _, err := cw.WriteString(string("sh.tangled.label.op")); err != nil {
3125 return err
3126 }
3127
3128 // t.Delete ([]*tangled.LabelOp_Operand) (slice)
3129 if len("delete") > 1000000 {
3130 return xerrors.Errorf("Value in field \"delete\" was too long")
3131 }
3132
3133 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("delete"))); err != nil {
3134 return err
3135 }
3136 if _, err := cw.WriteString(string("delete")); err != nil {
3137 return err
3138 }
3139
3140 if len(t.Delete) > 8192 {
3141 return xerrors.Errorf("Slice value in field t.Delete was too long")
3142 }
3143
3144 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Delete))); err != nil {
3145 return err
3146 }
3147 for _, v := range t.Delete {
3148 if err := v.MarshalCBOR(cw); err != nil {
3149 return err
3150 }
3151
3152 }
3153
3154 // t.Subject (string) (string)
3155 if len("subject") > 1000000 {
3156 return xerrors.Errorf("Value in field \"subject\" was too long")
3157 }
3158
3159 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
3160 return err
3161 }
3162 if _, err := cw.WriteString(string("subject")); err != nil {
3163 return err
3164 }
3165
3166 if len(t.Subject) > 1000000 {
3167 return xerrors.Errorf("Value in field t.Subject was too long")
3168 }
3169
3170 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
3171 return err
3172 }
3173 if _, err := cw.WriteString(string(t.Subject)); err != nil {
3174 return err
3175 }
3176
3177 // t.PerformedAt (string) (string)
3178 if len("performedAt") > 1000000 {
3179 return xerrors.Errorf("Value in field \"performedAt\" was too long")
3180 }
3181
3182 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("performedAt"))); err != nil {
3183 return err
3184 }
3185 if _, err := cw.WriteString(string("performedAt")); err != nil {
3186 return err
3187 }
3188
3189 if len(t.PerformedAt) > 1000000 {
3190 return xerrors.Errorf("Value in field t.PerformedAt was too long")
3191 }
3192
3193 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.PerformedAt))); err != nil {
3194 return err
3195 }
3196 if _, err := cw.WriteString(string(t.PerformedAt)); err != nil {
3197 return err
3198 }
3199 return nil
3200}
3201
3202func (t *LabelOp) UnmarshalCBOR(r io.Reader) (err error) {
3203 *t = LabelOp{}
3204
3205 cr := cbg.NewCborReader(r)
3206
3207 maj, extra, err := cr.ReadHeader()
3208 if err != nil {
3209 return err
3210 }
3211 defer func() {
3212 if err == io.EOF {
3213 err = io.ErrUnexpectedEOF
3214 }
3215 }()
3216
3217 if maj != cbg.MajMap {
3218 return fmt.Errorf("cbor input should be of type map")
3219 }
3220
3221 if extra > cbg.MaxLength {
3222 return fmt.Errorf("LabelOp: map struct too large (%d)", extra)
3223 }
3224
3225 n := extra
3226
3227 nameBuf := make([]byte, 11)
3228 for i := uint64(0); i < n; i++ {
3229 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3230 if err != nil {
3231 return err
3232 }
3233
3234 if !ok {
3235 // Field doesn't exist on this type, so ignore it
3236 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3237 return err
3238 }
3239 continue
3240 }
3241
3242 switch string(nameBuf[:nameLen]) {
3243 // t.Add ([]*tangled.LabelOp_Operand) (slice)
3244 case "add":
3245
3246 maj, extra, err = cr.ReadHeader()
3247 if err != nil {
3248 return err
3249 }
3250
3251 if extra > 8192 {
3252 return fmt.Errorf("t.Add: array too large (%d)", extra)
3253 }
3254
3255 if maj != cbg.MajArray {
3256 return fmt.Errorf("expected cbor array")
3257 }
3258
3259 if extra > 0 {
3260 t.Add = make([]*LabelOp_Operand, extra)
3261 }
3262
3263 for i := 0; i < int(extra); i++ {
3264 {
3265 var maj byte
3266 var extra uint64
3267 var err error
3268 _ = maj
3269 _ = extra
3270 _ = err
3271
3272 {
3273
3274 b, err := cr.ReadByte()
3275 if err != nil {
3276 return err
3277 }
3278 if b != cbg.CborNull[0] {
3279 if err := cr.UnreadByte(); err != nil {
3280 return err
3281 }
3282 t.Add[i] = new(LabelOp_Operand)
3283 if err := t.Add[i].UnmarshalCBOR(cr); err != nil {
3284 return xerrors.Errorf("unmarshaling t.Add[i] pointer: %w", err)
3285 }
3286 }
3287
3288 }
3289
3290 }
3291 }
3292 // t.LexiconTypeID (string) (string)
3293 case "$type":
3294
3295 {
3296 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3297 if err != nil {
3298 return err
3299 }
3300
3301 t.LexiconTypeID = string(sval)
3302 }
3303 // t.Delete ([]*tangled.LabelOp_Operand) (slice)
3304 case "delete":
3305
3306 maj, extra, err = cr.ReadHeader()
3307 if err != nil {
3308 return err
3309 }
3310
3311 if extra > 8192 {
3312 return fmt.Errorf("t.Delete: array too large (%d)", extra)
3313 }
3314
3315 if maj != cbg.MajArray {
3316 return fmt.Errorf("expected cbor array")
3317 }
3318
3319 if extra > 0 {
3320 t.Delete = make([]*LabelOp_Operand, extra)
3321 }
3322
3323 for i := 0; i < int(extra); i++ {
3324 {
3325 var maj byte
3326 var extra uint64
3327 var err error
3328 _ = maj
3329 _ = extra
3330 _ = err
3331
3332 {
3333
3334 b, err := cr.ReadByte()
3335 if err != nil {
3336 return err
3337 }
3338 if b != cbg.CborNull[0] {
3339 if err := cr.UnreadByte(); err != nil {
3340 return err
3341 }
3342 t.Delete[i] = new(LabelOp_Operand)
3343 if err := t.Delete[i].UnmarshalCBOR(cr); err != nil {
3344 return xerrors.Errorf("unmarshaling t.Delete[i] pointer: %w", err)
3345 }
3346 }
3347
3348 }
3349
3350 }
3351 }
3352 // t.Subject (string) (string)
3353 case "subject":
3354
3355 {
3356 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3357 if err != nil {
3358 return err
3359 }
3360
3361 t.Subject = string(sval)
3362 }
3363 // t.PerformedAt (string) (string)
3364 case "performedAt":
3365
3366 {
3367 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3368 if err != nil {
3369 return err
3370 }
3371
3372 t.PerformedAt = string(sval)
3373 }
3374
3375 default:
3376 // Field doesn't exist on this type, so ignore it
3377 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3378 return err
3379 }
3380 }
3381 }
3382
3383 return nil
3384}
3385func (t *LabelOp_Operand) MarshalCBOR(w io.Writer) error {
3386 if t == nil {
3387 _, err := w.Write(cbg.CborNull)
3388 return err
3389 }
3390
3391 cw := cbg.NewCborWriter(w)
3392
3393 if _, err := cw.Write([]byte{162}); err != nil {
3394 return err
3395 }
3396
3397 // t.Key (string) (string)
3398 if len("key") > 1000000 {
3399 return xerrors.Errorf("Value in field \"key\" was too long")
3400 }
3401
3402 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
3403 return err
3404 }
3405 if _, err := cw.WriteString(string("key")); err != nil {
3406 return err
3407 }
3408
3409 if len(t.Key) > 1000000 {
3410 return xerrors.Errorf("Value in field t.Key was too long")
3411 }
3412
3413 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
3414 return err
3415 }
3416 if _, err := cw.WriteString(string(t.Key)); err != nil {
3417 return err
3418 }
3419
3420 // t.Value (string) (string)
3421 if len("value") > 1000000 {
3422 return xerrors.Errorf("Value in field \"value\" was too long")
3423 }
3424
3425 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
3426 return err
3427 }
3428 if _, err := cw.WriteString(string("value")); err != nil {
3429 return err
3430 }
3431
3432 if len(t.Value) > 1000000 {
3433 return xerrors.Errorf("Value in field t.Value was too long")
3434 }
3435
3436 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
3437 return err
3438 }
3439 if _, err := cw.WriteString(string(t.Value)); err != nil {
3440 return err
3441 }
3442 return nil
3443}
3444
3445func (t *LabelOp_Operand) UnmarshalCBOR(r io.Reader) (err error) {
3446 *t = LabelOp_Operand{}
3447
3448 cr := cbg.NewCborReader(r)
3449
3450 maj, extra, err := cr.ReadHeader()
3451 if err != nil {
3452 return err
3453 }
3454 defer func() {
3455 if err == io.EOF {
3456 err = io.ErrUnexpectedEOF
3457 }
3458 }()
3459
3460 if maj != cbg.MajMap {
3461 return fmt.Errorf("cbor input should be of type map")
3462 }
3463
3464 if extra > cbg.MaxLength {
3465 return fmt.Errorf("LabelOp_Operand: map struct too large (%d)", extra)
3466 }
3467
3468 n := extra
3469
3470 nameBuf := make([]byte, 5)
3471 for i := uint64(0); i < n; i++ {
3472 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3473 if err != nil {
3474 return err
3475 }
3476
3477 if !ok {
3478 // Field doesn't exist on this type, so ignore it
3479 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3480 return err
3481 }
3482 continue
3483 }
3484
3485 switch string(nameBuf[:nameLen]) {
3486 // t.Key (string) (string)
3487 case "key":
3488
3489 {
3490 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3491 if err != nil {
3492 return err
3493 }
3494
3495 t.Key = string(sval)
3496 }
3497 // t.Value (string) (string)
3498 case "value":
3499
3500 {
3501 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3502 if err != nil {
3503 return err
3504 }
3505
3506 t.Value = string(sval)
3507 }
3508
3509 default:
3510 // Field doesn't exist on this type, so ignore it
3511 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3512 return err
3513 }
3514 }
3515 }
3516
3517 return nil
3518}
3519func (t *Pipeline) MarshalCBOR(w io.Writer) error {
3520 if t == nil {
3521 _, err := w.Write(cbg.CborNull)
3522 return err
3523 }
3524
3525 cw := cbg.NewCborWriter(w)
3526
3527 if _, err := cw.Write([]byte{163}); err != nil {
3528 return err
3529 }
3530
3531 // t.LexiconTypeID (string) (string)
3532 if len("$type") > 1000000 {
3533 return xerrors.Errorf("Value in field \"$type\" was too long")
3534 }
3535
3536 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3537 return err
3538 }
3539 if _, err := cw.WriteString(string("$type")); err != nil {
3540 return err
3541 }
3542
3543 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil {
3544 return err
3545 }
3546 if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil {
3547 return err
3548 }
3549
3550 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
3551 if len("workflows") > 1000000 {
3552 return xerrors.Errorf("Value in field \"workflows\" was too long")
3553 }
3554
3555 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil {
3556 return err
3557 }
3558 if _, err := cw.WriteString(string("workflows")); err != nil {
3559 return err
3560 }
3561
3562 if len(t.Workflows) > 8192 {
3563 return xerrors.Errorf("Slice value in field t.Workflows was too long")
3564 }
3565
3566 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil {
3567 return err
3568 }
3569 for _, v := range t.Workflows {
3570 if err := v.MarshalCBOR(cw); err != nil {
3571 return err
3572 }
3573
3574 }
3575
3576 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
3577 if len("triggerMetadata") > 1000000 {
3578 return xerrors.Errorf("Value in field \"triggerMetadata\" was too long")
3579 }
3580
3581 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil {
3582 return err
3583 }
3584 if _, err := cw.WriteString(string("triggerMetadata")); err != nil {
3585 return err
3586 }
3587
3588 if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil {
3589 return err
3590 }
3591 return nil
3592}
3593
3594func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) {
3595 *t = Pipeline{}
3596
3597 cr := cbg.NewCborReader(r)
3598
3599 maj, extra, err := cr.ReadHeader()
3600 if err != nil {
3601 return err
3602 }
3603 defer func() {
3604 if err == io.EOF {
3605 err = io.ErrUnexpectedEOF
3606 }
3607 }()
3608
3609 if maj != cbg.MajMap {
3610 return fmt.Errorf("cbor input should be of type map")
3611 }
3612
3613 if extra > cbg.MaxLength {
3614 return fmt.Errorf("Pipeline: map struct too large (%d)", extra)
3615 }
3616
3617 n := extra
3618
3619 nameBuf := make([]byte, 15)
3620 for i := uint64(0); i < n; i++ {
3621 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3622 if err != nil {
3623 return err
3624 }
3625
3626 if !ok {
3627 // Field doesn't exist on this type, so ignore it
3628 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3629 return err
3630 }
3631 continue
3632 }
3633
3634 switch string(nameBuf[:nameLen]) {
3635 // t.LexiconTypeID (string) (string)
3636 case "$type":
3637
3638 {
3639 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3640 if err != nil {
3641 return err
3642 }
3643
3644 t.LexiconTypeID = string(sval)
3645 }
3646 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
3647 case "workflows":
3648
3649 maj, extra, err = cr.ReadHeader()
3650 if err != nil {
3651 return err
3652 }
3653
3654 if extra > 8192 {
3655 return fmt.Errorf("t.Workflows: array too large (%d)", extra)
3656 }
3657
3658 if maj != cbg.MajArray {
3659 return fmt.Errorf("expected cbor array")
3660 }
3661
3662 if extra > 0 {
3663 t.Workflows = make([]*Pipeline_Workflow, extra)
3664 }
3665
3666 for i := 0; i < int(extra); i++ {
3667 {
3668 var maj byte
3669 var extra uint64
3670 var err error
3671 _ = maj
3672 _ = extra
3673 _ = err
3674
3675 {
3676
3677 b, err := cr.ReadByte()
3678 if err != nil {
3679 return err
3680 }
3681 if b != cbg.CborNull[0] {
3682 if err := cr.UnreadByte(); err != nil {
3683 return err
3684 }
3685 t.Workflows[i] = new(Pipeline_Workflow)
3686 if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil {
3687 return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err)
3688 }
3689 }
3690
3691 }
3692
3693 }
3694 }
3695 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
3696 case "triggerMetadata":
3697
3698 {
3699
3700 b, err := cr.ReadByte()
3701 if err != nil {
3702 return err
3703 }
3704 if b != cbg.CborNull[0] {
3705 if err := cr.UnreadByte(); err != nil {
3706 return err
3707 }
3708 t.TriggerMetadata = new(Pipeline_TriggerMetadata)
3709 if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil {
3710 return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err)
3711 }
3712 }
3713
3714 }
3715
3716 default:
3717 // Field doesn't exist on this type, so ignore it
3718 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3719 return err
3720 }
3721 }
3722 }
3723
3724 return nil
3725}
3726func (t *Pipeline_CloneOpts) MarshalCBOR(w io.Writer) error {
3727 if t == nil {
3728 _, err := w.Write(cbg.CborNull)
3729 return err
3730 }
3731
3732 cw := cbg.NewCborWriter(w)
3733
3734 if _, err := cw.Write([]byte{163}); err != nil {
3735 return err
3736 }
3737
3738 // t.Skip (bool) (bool)
3739 if len("skip") > 1000000 {
3740 return xerrors.Errorf("Value in field \"skip\" was too long")
3741 }
3742
3743 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("skip"))); err != nil {
3744 return err
3745 }
3746 if _, err := cw.WriteString(string("skip")); err != nil {
3747 return err
3748 }
3749
3750 if err := cbg.WriteBool(w, t.Skip); err != nil {
3751 return err
3752 }
3753
3754 // t.Depth (int64) (int64)
3755 if len("depth") > 1000000 {
3756 return xerrors.Errorf("Value in field \"depth\" was too long")
3757 }
3758
3759 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("depth"))); err != nil {
3760 return err
3761 }
3762 if _, err := cw.WriteString(string("depth")); err != nil {
3763 return err
3764 }
3765
3766 if t.Depth >= 0 {
3767 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Depth)); err != nil {
3768 return err
3769 }
3770 } else {
3771 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Depth-1)); err != nil {
3772 return err
3773 }
3774 }
3775
3776 // t.Submodules (bool) (bool)
3777 if len("submodules") > 1000000 {
3778 return xerrors.Errorf("Value in field \"submodules\" was too long")
3779 }
3780
3781 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("submodules"))); err != nil {
3782 return err
3783 }
3784 if _, err := cw.WriteString(string("submodules")); err != nil {
3785 return err
3786 }
3787
3788 if err := cbg.WriteBool(w, t.Submodules); err != nil {
3789 return err
3790 }
3791 return nil
3792}
3793
3794func (t *Pipeline_CloneOpts) UnmarshalCBOR(r io.Reader) (err error) {
3795 *t = Pipeline_CloneOpts{}
3796
3797 cr := cbg.NewCborReader(r)
3798
3799 maj, extra, err := cr.ReadHeader()
3800 if err != nil {
3801 return err
3802 }
3803 defer func() {
3804 if err == io.EOF {
3805 err = io.ErrUnexpectedEOF
3806 }
3807 }()
3808
3809 if maj != cbg.MajMap {
3810 return fmt.Errorf("cbor input should be of type map")
3811 }
3812
3813 if extra > cbg.MaxLength {
3814 return fmt.Errorf("Pipeline_CloneOpts: map struct too large (%d)", extra)
3815 }
3816
3817 n := extra
3818
3819 nameBuf := make([]byte, 10)
3820 for i := uint64(0); i < n; i++ {
3821 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3822 if err != nil {
3823 return err
3824 }
3825
3826 if !ok {
3827 // Field doesn't exist on this type, so ignore it
3828 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3829 return err
3830 }
3831 continue
3832 }
3833
3834 switch string(nameBuf[:nameLen]) {
3835 // t.Skip (bool) (bool)
3836 case "skip":
3837
3838 maj, extra, err = cr.ReadHeader()
3839 if err != nil {
3840 return err
3841 }
3842 if maj != cbg.MajOther {
3843 return fmt.Errorf("booleans must be major type 7")
3844 }
3845 switch extra {
3846 case 20:
3847 t.Skip = false
3848 case 21:
3849 t.Skip = true
3850 default:
3851 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
3852 }
3853 // t.Depth (int64) (int64)
3854 case "depth":
3855 {
3856 maj, extra, err := cr.ReadHeader()
3857 if err != nil {
3858 return err
3859 }
3860 var extraI int64
3861 switch maj {
3862 case cbg.MajUnsignedInt:
3863 extraI = int64(extra)
3864 if extraI < 0 {
3865 return fmt.Errorf("int64 positive overflow")
3866 }
3867 case cbg.MajNegativeInt:
3868 extraI = int64(extra)
3869 if extraI < 0 {
3870 return fmt.Errorf("int64 negative overflow")
3871 }
3872 extraI = -1 - extraI
3873 default:
3874 return fmt.Errorf("wrong type for int64 field: %d", maj)
3875 }
3876
3877 t.Depth = int64(extraI)
3878 }
3879 // t.Submodules (bool) (bool)
3880 case "submodules":
3881
3882 maj, extra, err = cr.ReadHeader()
3883 if err != nil {
3884 return err
3885 }
3886 if maj != cbg.MajOther {
3887 return fmt.Errorf("booleans must be major type 7")
3888 }
3889 switch extra {
3890 case 20:
3891 t.Submodules = false
3892 case 21:
3893 t.Submodules = true
3894 default:
3895 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
3896 }
3897
3898 default:
3899 // Field doesn't exist on this type, so ignore it
3900 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3901 return err
3902 }
3903 }
3904 }
3905
3906 return nil
3907}
3908func (t *Pipeline_ManualTriggerData) MarshalCBOR(w io.Writer) error {
3909 if t == nil {
3910 _, err := w.Write(cbg.CborNull)
3911 return err
3912 }
3913
3914 cw := cbg.NewCborWriter(w)
3915 fieldCount := 1
3916
3917 if t.Inputs == nil {
3918 fieldCount--
3919 }
3920
3921 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3922 return err
3923 }
3924
3925 // t.Inputs ([]*tangled.Pipeline_Pair) (slice)
3926 if t.Inputs != nil {
3927
3928 if len("inputs") > 1000000 {
3929 return xerrors.Errorf("Value in field \"inputs\" was too long")
3930 }
3931
3932 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
3933 return err
3934 }
3935 if _, err := cw.WriteString(string("inputs")); err != nil {
3936 return err
3937 }
3938
3939 if len(t.Inputs) > 8192 {
3940 return xerrors.Errorf("Slice value in field t.Inputs was too long")
3941 }
3942
3943 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
3944 return err
3945 }
3946 for _, v := range t.Inputs {
3947 if err := v.MarshalCBOR(cw); err != nil {
3948 return err
3949 }
3950
3951 }
3952 }
3953 return nil
3954}
3955
3956func (t *Pipeline_ManualTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
3957 *t = Pipeline_ManualTriggerData{}
3958
3959 cr := cbg.NewCborReader(r)
3960
3961 maj, extra, err := cr.ReadHeader()
3962 if err != nil {
3963 return err
3964 }
3965 defer func() {
3966 if err == io.EOF {
3967 err = io.ErrUnexpectedEOF
3968 }
3969 }()
3970
3971 if maj != cbg.MajMap {
3972 return fmt.Errorf("cbor input should be of type map")
3973 }
3974
3975 if extra > cbg.MaxLength {
3976 return fmt.Errorf("Pipeline_ManualTriggerData: map struct too large (%d)", extra)
3977 }
3978
3979 n := extra
3980
3981 nameBuf := make([]byte, 6)
3982 for i := uint64(0); i < n; i++ {
3983 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3984 if err != nil {
3985 return err
3986 }
3987
3988 if !ok {
3989 // Field doesn't exist on this type, so ignore it
3990 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3991 return err
3992 }
3993 continue
3994 }
3995
3996 switch string(nameBuf[:nameLen]) {
3997 // t.Inputs ([]*tangled.Pipeline_Pair) (slice)
3998 case "inputs":
3999
4000 maj, extra, err = cr.ReadHeader()
4001 if err != nil {
4002 return err
4003 }
4004
4005 if extra > 8192 {
4006 return fmt.Errorf("t.Inputs: array too large (%d)", extra)
4007 }
4008
4009 if maj != cbg.MajArray {
4010 return fmt.Errorf("expected cbor array")
4011 }
4012
4013 if extra > 0 {
4014 t.Inputs = make([]*Pipeline_Pair, extra)
4015 }
4016
4017 for i := 0; i < int(extra); i++ {
4018 {
4019 var maj byte
4020 var extra uint64
4021 var err error
4022 _ = maj
4023 _ = extra
4024 _ = err
4025
4026 {
4027
4028 b, err := cr.ReadByte()
4029 if err != nil {
4030 return err
4031 }
4032 if b != cbg.CborNull[0] {
4033 if err := cr.UnreadByte(); err != nil {
4034 return err
4035 }
4036 t.Inputs[i] = new(Pipeline_Pair)
4037 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
4038 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
4039 }
4040 }
4041
4042 }
4043
4044 }
4045 }
4046
4047 default:
4048 // Field doesn't exist on this type, so ignore it
4049 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4050 return err
4051 }
4052 }
4053 }
4054
4055 return nil
4056}
4057func (t *Pipeline_Pair) MarshalCBOR(w io.Writer) error {
4058 if t == nil {
4059 _, err := w.Write(cbg.CborNull)
4060 return err
4061 }
4062
4063 cw := cbg.NewCborWriter(w)
4064
4065 if _, err := cw.Write([]byte{162}); err != nil {
4066 return err
4067 }
4068
4069 // t.Key (string) (string)
4070 if len("key") > 1000000 {
4071 return xerrors.Errorf("Value in field \"key\" was too long")
4072 }
4073
4074 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
4075 return err
4076 }
4077 if _, err := cw.WriteString(string("key")); err != nil {
4078 return err
4079 }
4080
4081 if len(t.Key) > 1000000 {
4082 return xerrors.Errorf("Value in field t.Key was too long")
4083 }
4084
4085 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
4086 return err
4087 }
4088 if _, err := cw.WriteString(string(t.Key)); err != nil {
4089 return err
4090 }
4091
4092 // t.Value (string) (string)
4093 if len("value") > 1000000 {
4094 return xerrors.Errorf("Value in field \"value\" was too long")
4095 }
4096
4097 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
4098 return err
4099 }
4100 if _, err := cw.WriteString(string("value")); err != nil {
4101 return err
4102 }
4103
4104 if len(t.Value) > 1000000 {
4105 return xerrors.Errorf("Value in field t.Value was too long")
4106 }
4107
4108 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
4109 return err
4110 }
4111 if _, err := cw.WriteString(string(t.Value)); err != nil {
4112 return err
4113 }
4114 return nil
4115}
4116
4117func (t *Pipeline_Pair) UnmarshalCBOR(r io.Reader) (err error) {
4118 *t = Pipeline_Pair{}
4119
4120 cr := cbg.NewCborReader(r)
4121
4122 maj, extra, err := cr.ReadHeader()
4123 if err != nil {
4124 return err
4125 }
4126 defer func() {
4127 if err == io.EOF {
4128 err = io.ErrUnexpectedEOF
4129 }
4130 }()
4131
4132 if maj != cbg.MajMap {
4133 return fmt.Errorf("cbor input should be of type map")
4134 }
4135
4136 if extra > cbg.MaxLength {
4137 return fmt.Errorf("Pipeline_Pair: map struct too large (%d)", extra)
4138 }
4139
4140 n := extra
4141
4142 nameBuf := make([]byte, 5)
4143 for i := uint64(0); i < n; i++ {
4144 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4145 if err != nil {
4146 return err
4147 }
4148
4149 if !ok {
4150 // Field doesn't exist on this type, so ignore it
4151 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4152 return err
4153 }
4154 continue
4155 }
4156
4157 switch string(nameBuf[:nameLen]) {
4158 // t.Key (string) (string)
4159 case "key":
4160
4161 {
4162 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4163 if err != nil {
4164 return err
4165 }
4166
4167 t.Key = string(sval)
4168 }
4169 // t.Value (string) (string)
4170 case "value":
4171
4172 {
4173 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4174 if err != nil {
4175 return err
4176 }
4177
4178 t.Value = string(sval)
4179 }
4180
4181 default:
4182 // Field doesn't exist on this type, so ignore it
4183 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4184 return err
4185 }
4186 }
4187 }
4188
4189 return nil
4190}
4191func (t *Pipeline_PullRequestTriggerData) MarshalCBOR(w io.Writer) error {
4192 if t == nil {
4193 _, err := w.Write(cbg.CborNull)
4194 return err
4195 }
4196
4197 cw := cbg.NewCborWriter(w)
4198
4199 if _, err := cw.Write([]byte{164}); err != nil {
4200 return err
4201 }
4202
4203 // t.Action (string) (string)
4204 if len("action") > 1000000 {
4205 return xerrors.Errorf("Value in field \"action\" was too long")
4206 }
4207
4208 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("action"))); err != nil {
4209 return err
4210 }
4211 if _, err := cw.WriteString(string("action")); err != nil {
4212 return err
4213 }
4214
4215 if len(t.Action) > 1000000 {
4216 return xerrors.Errorf("Value in field t.Action was too long")
4217 }
4218
4219 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Action))); err != nil {
4220 return err
4221 }
4222 if _, err := cw.WriteString(string(t.Action)); err != nil {
4223 return err
4224 }
4225
4226 // t.SourceSha (string) (string)
4227 if len("sourceSha") > 1000000 {
4228 return xerrors.Errorf("Value in field \"sourceSha\" was too long")
4229 }
4230
4231 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceSha"))); err != nil {
4232 return err
4233 }
4234 if _, err := cw.WriteString(string("sourceSha")); err != nil {
4235 return err
4236 }
4237
4238 if len(t.SourceSha) > 1000000 {
4239 return xerrors.Errorf("Value in field t.SourceSha was too long")
4240 }
4241
4242 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceSha))); err != nil {
4243 return err
4244 }
4245 if _, err := cw.WriteString(string(t.SourceSha)); err != nil {
4246 return err
4247 }
4248
4249 // t.SourceBranch (string) (string)
4250 if len("sourceBranch") > 1000000 {
4251 return xerrors.Errorf("Value in field \"sourceBranch\" was too long")
4252 }
4253
4254 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceBranch"))); err != nil {
4255 return err
4256 }
4257 if _, err := cw.WriteString(string("sourceBranch")); err != nil {
4258 return err
4259 }
4260
4261 if len(t.SourceBranch) > 1000000 {
4262 return xerrors.Errorf("Value in field t.SourceBranch was too long")
4263 }
4264
4265 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceBranch))); err != nil {
4266 return err
4267 }
4268 if _, err := cw.WriteString(string(t.SourceBranch)); err != nil {
4269 return err
4270 }
4271
4272 // t.TargetBranch (string) (string)
4273 if len("targetBranch") > 1000000 {
4274 return xerrors.Errorf("Value in field \"targetBranch\" was too long")
4275 }
4276
4277 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil {
4278 return err
4279 }
4280 if _, err := cw.WriteString(string("targetBranch")); err != nil {
4281 return err
4282 }
4283
4284 if len(t.TargetBranch) > 1000000 {
4285 return xerrors.Errorf("Value in field t.TargetBranch was too long")
4286 }
4287
4288 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil {
4289 return err
4290 }
4291 if _, err := cw.WriteString(string(t.TargetBranch)); err != nil {
4292 return err
4293 }
4294 return nil
4295}
4296
4297func (t *Pipeline_PullRequestTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
4298 *t = Pipeline_PullRequestTriggerData{}
4299
4300 cr := cbg.NewCborReader(r)
4301
4302 maj, extra, err := cr.ReadHeader()
4303 if err != nil {
4304 return err
4305 }
4306 defer func() {
4307 if err == io.EOF {
4308 err = io.ErrUnexpectedEOF
4309 }
4310 }()
4311
4312 if maj != cbg.MajMap {
4313 return fmt.Errorf("cbor input should be of type map")
4314 }
4315
4316 if extra > cbg.MaxLength {
4317 return fmt.Errorf("Pipeline_PullRequestTriggerData: map struct too large (%d)", extra)
4318 }
4319
4320 n := extra
4321
4322 nameBuf := make([]byte, 12)
4323 for i := uint64(0); i < n; i++ {
4324 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4325 if err != nil {
4326 return err
4327 }
4328
4329 if !ok {
4330 // Field doesn't exist on this type, so ignore it
4331 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4332 return err
4333 }
4334 continue
4335 }
4336
4337 switch string(nameBuf[:nameLen]) {
4338 // t.Action (string) (string)
4339 case "action":
4340
4341 {
4342 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4343 if err != nil {
4344 return err
4345 }
4346
4347 t.Action = string(sval)
4348 }
4349 // t.SourceSha (string) (string)
4350 case "sourceSha":
4351
4352 {
4353 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4354 if err != nil {
4355 return err
4356 }
4357
4358 t.SourceSha = string(sval)
4359 }
4360 // t.SourceBranch (string) (string)
4361 case "sourceBranch":
4362
4363 {
4364 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4365 if err != nil {
4366 return err
4367 }
4368
4369 t.SourceBranch = string(sval)
4370 }
4371 // t.TargetBranch (string) (string)
4372 case "targetBranch":
4373
4374 {
4375 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4376 if err != nil {
4377 return err
4378 }
4379
4380 t.TargetBranch = string(sval)
4381 }
4382
4383 default:
4384 // Field doesn't exist on this type, so ignore it
4385 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4386 return err
4387 }
4388 }
4389 }
4390
4391 return nil
4392}
4393func (t *Pipeline_PushTriggerData) MarshalCBOR(w io.Writer) error {
4394 if t == nil {
4395 _, err := w.Write(cbg.CborNull)
4396 return err
4397 }
4398
4399 cw := cbg.NewCborWriter(w)
4400
4401 if _, err := cw.Write([]byte{163}); err != nil {
4402 return err
4403 }
4404
4405 // t.Ref (string) (string)
4406 if len("ref") > 1000000 {
4407 return xerrors.Errorf("Value in field \"ref\" was too long")
4408 }
4409
4410 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
4411 return err
4412 }
4413 if _, err := cw.WriteString(string("ref")); err != nil {
4414 return err
4415 }
4416
4417 if len(t.Ref) > 1000000 {
4418 return xerrors.Errorf("Value in field t.Ref was too long")
4419 }
4420
4421 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
4422 return err
4423 }
4424 if _, err := cw.WriteString(string(t.Ref)); err != nil {
4425 return err
4426 }
4427
4428 // t.NewSha (string) (string)
4429 if len("newSha") > 1000000 {
4430 return xerrors.Errorf("Value in field \"newSha\" was too long")
4431 }
4432
4433 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
4434 return err
4435 }
4436 if _, err := cw.WriteString(string("newSha")); err != nil {
4437 return err
4438 }
4439
4440 if len(t.NewSha) > 1000000 {
4441 return xerrors.Errorf("Value in field t.NewSha was too long")
4442 }
4443
4444 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
4445 return err
4446 }
4447 if _, err := cw.WriteString(string(t.NewSha)); err != nil {
4448 return err
4449 }
4450
4451 // t.OldSha (string) (string)
4452 if len("oldSha") > 1000000 {
4453 return xerrors.Errorf("Value in field \"oldSha\" was too long")
4454 }
4455
4456 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
4457 return err
4458 }
4459 if _, err := cw.WriteString(string("oldSha")); err != nil {
4460 return err
4461 }
4462
4463 if len(t.OldSha) > 1000000 {
4464 return xerrors.Errorf("Value in field t.OldSha was too long")
4465 }
4466
4467 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
4468 return err
4469 }
4470 if _, err := cw.WriteString(string(t.OldSha)); err != nil {
4471 return err
4472 }
4473 return nil
4474}
4475
4476func (t *Pipeline_PushTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
4477 *t = Pipeline_PushTriggerData{}
4478
4479 cr := cbg.NewCborReader(r)
4480
4481 maj, extra, err := cr.ReadHeader()
4482 if err != nil {
4483 return err
4484 }
4485 defer func() {
4486 if err == io.EOF {
4487 err = io.ErrUnexpectedEOF
4488 }
4489 }()
4490
4491 if maj != cbg.MajMap {
4492 return fmt.Errorf("cbor input should be of type map")
4493 }
4494
4495 if extra > cbg.MaxLength {
4496 return fmt.Errorf("Pipeline_PushTriggerData: map struct too large (%d)", extra)
4497 }
4498
4499 n := extra
4500
4501 nameBuf := make([]byte, 6)
4502 for i := uint64(0); i < n; i++ {
4503 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4504 if err != nil {
4505 return err
4506 }
4507
4508 if !ok {
4509 // Field doesn't exist on this type, so ignore it
4510 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4511 return err
4512 }
4513 continue
4514 }
4515
4516 switch string(nameBuf[:nameLen]) {
4517 // t.Ref (string) (string)
4518 case "ref":
4519
4520 {
4521 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4522 if err != nil {
4523 return err
4524 }
4525
4526 t.Ref = string(sval)
4527 }
4528 // t.NewSha (string) (string)
4529 case "newSha":
4530
4531 {
4532 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4533 if err != nil {
4534 return err
4535 }
4536
4537 t.NewSha = string(sval)
4538 }
4539 // t.OldSha (string) (string)
4540 case "oldSha":
4541
4542 {
4543 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4544 if err != nil {
4545 return err
4546 }
4547
4548 t.OldSha = string(sval)
4549 }
4550
4551 default:
4552 // Field doesn't exist on this type, so ignore it
4553 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4554 return err
4555 }
4556 }
4557 }
4558
4559 return nil
4560}
4561func (t *PipelineStatus) MarshalCBOR(w io.Writer) error {
4562 if t == nil {
4563 _, err := w.Write(cbg.CborNull)
4564 return err
4565 }
4566
4567 cw := cbg.NewCborWriter(w)
4568 fieldCount := 7
4569
4570 if t.Error == nil {
4571 fieldCount--
4572 }
4573
4574 if t.ExitCode == nil {
4575 fieldCount--
4576 }
4577
4578 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4579 return err
4580 }
4581
4582 // t.LexiconTypeID (string) (string)
4583 if len("$type") > 1000000 {
4584 return xerrors.Errorf("Value in field \"$type\" was too long")
4585 }
4586
4587 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
4588 return err
4589 }
4590 if _, err := cw.WriteString(string("$type")); err != nil {
4591 return err
4592 }
4593
4594 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline.status"))); err != nil {
4595 return err
4596 }
4597 if _, err := cw.WriteString(string("sh.tangled.pipeline.status")); err != nil {
4598 return err
4599 }
4600
4601 // t.Error (string) (string)
4602 if t.Error != nil {
4603
4604 if len("error") > 1000000 {
4605 return xerrors.Errorf("Value in field \"error\" was too long")
4606 }
4607
4608 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("error"))); err != nil {
4609 return err
4610 }
4611 if _, err := cw.WriteString(string("error")); err != nil {
4612 return err
4613 }
4614
4615 if t.Error == nil {
4616 if _, err := cw.Write(cbg.CborNull); err != nil {
4617 return err
4618 }
4619 } else {
4620 if len(*t.Error) > 1000000 {
4621 return xerrors.Errorf("Value in field t.Error was too long")
4622 }
4623
4624 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Error))); err != nil {
4625 return err
4626 }
4627 if _, err := cw.WriteString(string(*t.Error)); err != nil {
4628 return err
4629 }
4630 }
4631 }
4632
4633 // t.Status (string) (string)
4634 if len("status") > 1000000 {
4635 return xerrors.Errorf("Value in field \"status\" was too long")
4636 }
4637
4638 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
4639 return err
4640 }
4641 if _, err := cw.WriteString(string("status")); err != nil {
4642 return err
4643 }
4644
4645 if len(t.Status) > 1000000 {
4646 return xerrors.Errorf("Value in field t.Status was too long")
4647 }
4648
4649 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
4650 return err
4651 }
4652 if _, err := cw.WriteString(string(t.Status)); err != nil {
4653 return err
4654 }
4655
4656 // t.ExitCode (int64) (int64)
4657 if t.ExitCode != nil {
4658
4659 if len("exitCode") > 1000000 {
4660 return xerrors.Errorf("Value in field \"exitCode\" was too long")
4661 }
4662
4663 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("exitCode"))); err != nil {
4664 return err
4665 }
4666 if _, err := cw.WriteString(string("exitCode")); err != nil {
4667 return err
4668 }
4669
4670 if t.ExitCode == nil {
4671 if _, err := cw.Write(cbg.CborNull); err != nil {
4672 return err
4673 }
4674 } else {
4675 if *t.ExitCode >= 0 {
4676 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.ExitCode)); err != nil {
4677 return err
4678 }
4679 } else {
4680 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.ExitCode-1)); err != nil {
4681 return err
4682 }
4683 }
4684 }
4685
4686 }
4687
4688 // t.Pipeline (string) (string)
4689 if len("pipeline") > 1000000 {
4690 return xerrors.Errorf("Value in field \"pipeline\" was too long")
4691 }
4692
4693 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pipeline"))); err != nil {
4694 return err
4695 }
4696 if _, err := cw.WriteString(string("pipeline")); err != nil {
4697 return err
4698 }
4699
4700 if len(t.Pipeline) > 1000000 {
4701 return xerrors.Errorf("Value in field t.Pipeline was too long")
4702 }
4703
4704 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pipeline))); err != nil {
4705 return err
4706 }
4707 if _, err := cw.WriteString(string(t.Pipeline)); err != nil {
4708 return err
4709 }
4710
4711 // t.Workflow (string) (string)
4712 if len("workflow") > 1000000 {
4713 return xerrors.Errorf("Value in field \"workflow\" was too long")
4714 }
4715
4716 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil {
4717 return err
4718 }
4719 if _, err := cw.WriteString(string("workflow")); err != nil {
4720 return err
4721 }
4722
4723 if len(t.Workflow) > 1000000 {
4724 return xerrors.Errorf("Value in field t.Workflow was too long")
4725 }
4726
4727 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil {
4728 return err
4729 }
4730 if _, err := cw.WriteString(string(t.Workflow)); err != nil {
4731 return err
4732 }
4733
4734 // t.CreatedAt (string) (string)
4735 if len("createdAt") > 1000000 {
4736 return xerrors.Errorf("Value in field \"createdAt\" was too long")
4737 }
4738
4739 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
4740 return err
4741 }
4742 if _, err := cw.WriteString(string("createdAt")); err != nil {
4743 return err
4744 }
4745
4746 if len(t.CreatedAt) > 1000000 {
4747 return xerrors.Errorf("Value in field t.CreatedAt was too long")
4748 }
4749
4750 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
4751 return err
4752 }
4753 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
4754 return err
4755 }
4756 return nil
4757}
4758
4759func (t *PipelineStatus) UnmarshalCBOR(r io.Reader) (err error) {
4760 *t = PipelineStatus{}
4761
4762 cr := cbg.NewCborReader(r)
4763
4764 maj, extra, err := cr.ReadHeader()
4765 if err != nil {
4766 return err
4767 }
4768 defer func() {
4769 if err == io.EOF {
4770 err = io.ErrUnexpectedEOF
4771 }
4772 }()
4773
4774 if maj != cbg.MajMap {
4775 return fmt.Errorf("cbor input should be of type map")
4776 }
4777
4778 if extra > cbg.MaxLength {
4779 return fmt.Errorf("PipelineStatus: map struct too large (%d)", extra)
4780 }
4781
4782 n := extra
4783
4784 nameBuf := make([]byte, 9)
4785 for i := uint64(0); i < n; i++ {
4786 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4787 if err != nil {
4788 return err
4789 }
4790
4791 if !ok {
4792 // Field doesn't exist on this type, so ignore it
4793 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4794 return err
4795 }
4796 continue
4797 }
4798
4799 switch string(nameBuf[:nameLen]) {
4800 // t.LexiconTypeID (string) (string)
4801 case "$type":
4802
4803 {
4804 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4805 if err != nil {
4806 return err
4807 }
4808
4809 t.LexiconTypeID = string(sval)
4810 }
4811 // t.Error (string) (string)
4812 case "error":
4813
4814 {
4815 b, err := cr.ReadByte()
4816 if err != nil {
4817 return err
4818 }
4819 if b != cbg.CborNull[0] {
4820 if err := cr.UnreadByte(); err != nil {
4821 return err
4822 }
4823
4824 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4825 if err != nil {
4826 return err
4827 }
4828
4829 t.Error = (*string)(&sval)
4830 }
4831 }
4832 // t.Status (string) (string)
4833 case "status":
4834
4835 {
4836 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4837 if err != nil {
4838 return err
4839 }
4840
4841 t.Status = string(sval)
4842 }
4843 // t.ExitCode (int64) (int64)
4844 case "exitCode":
4845 {
4846
4847 b, err := cr.ReadByte()
4848 if err != nil {
4849 return err
4850 }
4851 if b != cbg.CborNull[0] {
4852 if err := cr.UnreadByte(); err != nil {
4853 return err
4854 }
4855 maj, extra, err := cr.ReadHeader()
4856 if err != nil {
4857 return err
4858 }
4859 var extraI int64
4860 switch maj {
4861 case cbg.MajUnsignedInt:
4862 extraI = int64(extra)
4863 if extraI < 0 {
4864 return fmt.Errorf("int64 positive overflow")
4865 }
4866 case cbg.MajNegativeInt:
4867 extraI = int64(extra)
4868 if extraI < 0 {
4869 return fmt.Errorf("int64 negative overflow")
4870 }
4871 extraI = -1 - extraI
4872 default:
4873 return fmt.Errorf("wrong type for int64 field: %d", maj)
4874 }
4875
4876 t.ExitCode = (*int64)(&extraI)
4877 }
4878 }
4879 // t.Pipeline (string) (string)
4880 case "pipeline":
4881
4882 {
4883 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4884 if err != nil {
4885 return err
4886 }
4887
4888 t.Pipeline = string(sval)
4889 }
4890 // t.Workflow (string) (string)
4891 case "workflow":
4892
4893 {
4894 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4895 if err != nil {
4896 return err
4897 }
4898
4899 t.Workflow = string(sval)
4900 }
4901 // t.CreatedAt (string) (string)
4902 case "createdAt":
4903
4904 {
4905 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4906 if err != nil {
4907 return err
4908 }
4909
4910 t.CreatedAt = string(sval)
4911 }
4912
4913 default:
4914 // Field doesn't exist on this type, so ignore it
4915 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4916 return err
4917 }
4918 }
4919 }
4920
4921 return nil
4922}
4923func (t *Pipeline_TriggerMetadata) MarshalCBOR(w io.Writer) error {
4924 if t == nil {
4925 _, err := w.Write(cbg.CborNull)
4926 return err
4927 }
4928
4929 cw := cbg.NewCborWriter(w)
4930 fieldCount := 5
4931
4932 if t.Manual == nil {
4933 fieldCount--
4934 }
4935
4936 if t.PullRequest == nil {
4937 fieldCount--
4938 }
4939
4940 if t.Push == nil {
4941 fieldCount--
4942 }
4943
4944 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4945 return err
4946 }
4947
4948 // t.Kind (string) (string)
4949 if len("kind") > 1000000 {
4950 return xerrors.Errorf("Value in field \"kind\" was too long")
4951 }
4952
4953 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("kind"))); err != nil {
4954 return err
4955 }
4956 if _, err := cw.WriteString(string("kind")); err != nil {
4957 return err
4958 }
4959
4960 if len(t.Kind) > 1000000 {
4961 return xerrors.Errorf("Value in field t.Kind was too long")
4962 }
4963
4964 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Kind))); err != nil {
4965 return err
4966 }
4967 if _, err := cw.WriteString(string(t.Kind)); err != nil {
4968 return err
4969 }
4970
4971 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
4972 if t.Push != nil {
4973
4974 if len("push") > 1000000 {
4975 return xerrors.Errorf("Value in field \"push\" was too long")
4976 }
4977
4978 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("push"))); err != nil {
4979 return err
4980 }
4981 if _, err := cw.WriteString(string("push")); err != nil {
4982 return err
4983 }
4984
4985 if err := t.Push.MarshalCBOR(cw); err != nil {
4986 return err
4987 }
4988 }
4989
4990 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
4991 if len("repo") > 1000000 {
4992 return xerrors.Errorf("Value in field \"repo\" was too long")
4993 }
4994
4995 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
4996 return err
4997 }
4998 if _, err := cw.WriteString(string("repo")); err != nil {
4999 return err
5000 }
5001
5002 if err := t.Repo.MarshalCBOR(cw); err != nil {
5003 return err
5004 }
5005
5006 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
5007 if t.Manual != nil {
5008
5009 if len("manual") > 1000000 {
5010 return xerrors.Errorf("Value in field \"manual\" was too long")
5011 }
5012
5013 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("manual"))); err != nil {
5014 return err
5015 }
5016 if _, err := cw.WriteString(string("manual")); err != nil {
5017 return err
5018 }
5019
5020 if err := t.Manual.MarshalCBOR(cw); err != nil {
5021 return err
5022 }
5023 }
5024
5025 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
5026 if t.PullRequest != nil {
5027
5028 if len("pullRequest") > 1000000 {
5029 return xerrors.Errorf("Value in field \"pullRequest\" was too long")
5030 }
5031
5032 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullRequest"))); err != nil {
5033 return err
5034 }
5035 if _, err := cw.WriteString(string("pullRequest")); err != nil {
5036 return err
5037 }
5038
5039 if err := t.PullRequest.MarshalCBOR(cw); err != nil {
5040 return err
5041 }
5042 }
5043 return nil
5044}
5045
5046func (t *Pipeline_TriggerMetadata) UnmarshalCBOR(r io.Reader) (err error) {
5047 *t = Pipeline_TriggerMetadata{}
5048
5049 cr := cbg.NewCborReader(r)
5050
5051 maj, extra, err := cr.ReadHeader()
5052 if err != nil {
5053 return err
5054 }
5055 defer func() {
5056 if err == io.EOF {
5057 err = io.ErrUnexpectedEOF
5058 }
5059 }()
5060
5061 if maj != cbg.MajMap {
5062 return fmt.Errorf("cbor input should be of type map")
5063 }
5064
5065 if extra > cbg.MaxLength {
5066 return fmt.Errorf("Pipeline_TriggerMetadata: map struct too large (%d)", extra)
5067 }
5068
5069 n := extra
5070
5071 nameBuf := make([]byte, 11)
5072 for i := uint64(0); i < n; i++ {
5073 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5074 if err != nil {
5075 return err
5076 }
5077
5078 if !ok {
5079 // Field doesn't exist on this type, so ignore it
5080 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5081 return err
5082 }
5083 continue
5084 }
5085
5086 switch string(nameBuf[:nameLen]) {
5087 // t.Kind (string) (string)
5088 case "kind":
5089
5090 {
5091 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5092 if err != nil {
5093 return err
5094 }
5095
5096 t.Kind = string(sval)
5097 }
5098 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
5099 case "push":
5100
5101 {
5102
5103 b, err := cr.ReadByte()
5104 if err != nil {
5105 return err
5106 }
5107 if b != cbg.CborNull[0] {
5108 if err := cr.UnreadByte(); err != nil {
5109 return err
5110 }
5111 t.Push = new(Pipeline_PushTriggerData)
5112 if err := t.Push.UnmarshalCBOR(cr); err != nil {
5113 return xerrors.Errorf("unmarshaling t.Push pointer: %w", err)
5114 }
5115 }
5116
5117 }
5118 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
5119 case "repo":
5120
5121 {
5122
5123 b, err := cr.ReadByte()
5124 if err != nil {
5125 return err
5126 }
5127 if b != cbg.CborNull[0] {
5128 if err := cr.UnreadByte(); err != nil {
5129 return err
5130 }
5131 t.Repo = new(Pipeline_TriggerRepo)
5132 if err := t.Repo.UnmarshalCBOR(cr); err != nil {
5133 return xerrors.Errorf("unmarshaling t.Repo pointer: %w", err)
5134 }
5135 }
5136
5137 }
5138 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
5139 case "manual":
5140
5141 {
5142
5143 b, err := cr.ReadByte()
5144 if err != nil {
5145 return err
5146 }
5147 if b != cbg.CborNull[0] {
5148 if err := cr.UnreadByte(); err != nil {
5149 return err
5150 }
5151 t.Manual = new(Pipeline_ManualTriggerData)
5152 if err := t.Manual.UnmarshalCBOR(cr); err != nil {
5153 return xerrors.Errorf("unmarshaling t.Manual pointer: %w", err)
5154 }
5155 }
5156
5157 }
5158 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
5159 case "pullRequest":
5160
5161 {
5162
5163 b, err := cr.ReadByte()
5164 if err != nil {
5165 return err
5166 }
5167 if b != cbg.CborNull[0] {
5168 if err := cr.UnreadByte(); err != nil {
5169 return err
5170 }
5171 t.PullRequest = new(Pipeline_PullRequestTriggerData)
5172 if err := t.PullRequest.UnmarshalCBOR(cr); err != nil {
5173 return xerrors.Errorf("unmarshaling t.PullRequest pointer: %w", err)
5174 }
5175 }
5176
5177 }
5178
5179 default:
5180 // Field doesn't exist on this type, so ignore it
5181 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5182 return err
5183 }
5184 }
5185 }
5186
5187 return nil
5188}
5189func (t *Pipeline_TriggerRepo) MarshalCBOR(w io.Writer) error {
5190 if t == nil {
5191 _, err := w.Write(cbg.CborNull)
5192 return err
5193 }
5194
5195 cw := cbg.NewCborWriter(w)
5196
5197 if _, err := cw.Write([]byte{164}); err != nil {
5198 return err
5199 }
5200
5201 // t.Did (string) (string)
5202 if len("did") > 1000000 {
5203 return xerrors.Errorf("Value in field \"did\" was too long")
5204 }
5205
5206 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil {
5207 return err
5208 }
5209 if _, err := cw.WriteString(string("did")); err != nil {
5210 return err
5211 }
5212
5213 if len(t.Did) > 1000000 {
5214 return xerrors.Errorf("Value in field t.Did was too long")
5215 }
5216
5217 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil {
5218 return err
5219 }
5220 if _, err := cw.WriteString(string(t.Did)); err != nil {
5221 return err
5222 }
5223
5224 // t.Knot (string) (string)
5225 if len("knot") > 1000000 {
5226 return xerrors.Errorf("Value in field \"knot\" was too long")
5227 }
5228
5229 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
5230 return err
5231 }
5232 if _, err := cw.WriteString(string("knot")); err != nil {
5233 return err
5234 }
5235
5236 if len(t.Knot) > 1000000 {
5237 return xerrors.Errorf("Value in field t.Knot was too long")
5238 }
5239
5240 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
5241 return err
5242 }
5243 if _, err := cw.WriteString(string(t.Knot)); err != nil {
5244 return err
5245 }
5246
5247 // t.Repo (string) (string)
5248 if len("repo") > 1000000 {
5249 return xerrors.Errorf("Value in field \"repo\" was too long")
5250 }
5251
5252 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5253 return err
5254 }
5255 if _, err := cw.WriteString(string("repo")); err != nil {
5256 return err
5257 }
5258
5259 if len(t.Repo) > 1000000 {
5260 return xerrors.Errorf("Value in field t.Repo was too long")
5261 }
5262
5263 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
5264 return err
5265 }
5266 if _, err := cw.WriteString(string(t.Repo)); err != nil {
5267 return err
5268 }
5269
5270 // t.DefaultBranch (string) (string)
5271 if len("defaultBranch") > 1000000 {
5272 return xerrors.Errorf("Value in field \"defaultBranch\" was too long")
5273 }
5274
5275 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("defaultBranch"))); err != nil {
5276 return err
5277 }
5278 if _, err := cw.WriteString(string("defaultBranch")); err != nil {
5279 return err
5280 }
5281
5282 if len(t.DefaultBranch) > 1000000 {
5283 return xerrors.Errorf("Value in field t.DefaultBranch was too long")
5284 }
5285
5286 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.DefaultBranch))); err != nil {
5287 return err
5288 }
5289 if _, err := cw.WriteString(string(t.DefaultBranch)); err != nil {
5290 return err
5291 }
5292 return nil
5293}
5294
5295func (t *Pipeline_TriggerRepo) UnmarshalCBOR(r io.Reader) (err error) {
5296 *t = Pipeline_TriggerRepo{}
5297
5298 cr := cbg.NewCborReader(r)
5299
5300 maj, extra, err := cr.ReadHeader()
5301 if err != nil {
5302 return err
5303 }
5304 defer func() {
5305 if err == io.EOF {
5306 err = io.ErrUnexpectedEOF
5307 }
5308 }()
5309
5310 if maj != cbg.MajMap {
5311 return fmt.Errorf("cbor input should be of type map")
5312 }
5313
5314 if extra > cbg.MaxLength {
5315 return fmt.Errorf("Pipeline_TriggerRepo: map struct too large (%d)", extra)
5316 }
5317
5318 n := extra
5319
5320 nameBuf := make([]byte, 13)
5321 for i := uint64(0); i < n; i++ {
5322 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5323 if err != nil {
5324 return err
5325 }
5326
5327 if !ok {
5328 // Field doesn't exist on this type, so ignore it
5329 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5330 return err
5331 }
5332 continue
5333 }
5334
5335 switch string(nameBuf[:nameLen]) {
5336 // t.Did (string) (string)
5337 case "did":
5338
5339 {
5340 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5341 if err != nil {
5342 return err
5343 }
5344
5345 t.Did = string(sval)
5346 }
5347 // t.Knot (string) (string)
5348 case "knot":
5349
5350 {
5351 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5352 if err != nil {
5353 return err
5354 }
5355
5356 t.Knot = string(sval)
5357 }
5358 // t.Repo (string) (string)
5359 case "repo":
5360
5361 {
5362 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5363 if err != nil {
5364 return err
5365 }
5366
5367 t.Repo = string(sval)
5368 }
5369 // t.DefaultBranch (string) (string)
5370 case "defaultBranch":
5371
5372 {
5373 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5374 if err != nil {
5375 return err
5376 }
5377
5378 t.DefaultBranch = string(sval)
5379 }
5380
5381 default:
5382 // Field doesn't exist on this type, so ignore it
5383 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5384 return err
5385 }
5386 }
5387 }
5388
5389 return nil
5390}
5391func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error {
5392 if t == nil {
5393 _, err := w.Write(cbg.CborNull)
5394 return err
5395 }
5396
5397 cw := cbg.NewCborWriter(w)
5398
5399 if _, err := cw.Write([]byte{164}); err != nil {
5400 return err
5401 }
5402
5403 // t.Raw (string) (string)
5404 if len("raw") > 1000000 {
5405 return xerrors.Errorf("Value in field \"raw\" was too long")
5406 }
5407
5408 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("raw"))); err != nil {
5409 return err
5410 }
5411 if _, err := cw.WriteString(string("raw")); err != nil {
5412 return err
5413 }
5414
5415 if len(t.Raw) > 1000000 {
5416 return xerrors.Errorf("Value in field t.Raw was too long")
5417 }
5418
5419 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Raw))); err != nil {
5420 return err
5421 }
5422 if _, err := cw.WriteString(string(t.Raw)); err != nil {
5423 return err
5424 }
5425
5426 // t.Name (string) (string)
5427 if len("name") > 1000000 {
5428 return xerrors.Errorf("Value in field \"name\" was too long")
5429 }
5430
5431 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5432 return err
5433 }
5434 if _, err := cw.WriteString(string("name")); err != nil {
5435 return err
5436 }
5437
5438 if len(t.Name) > 1000000 {
5439 return xerrors.Errorf("Value in field t.Name was too long")
5440 }
5441
5442 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5443 return err
5444 }
5445 if _, err := cw.WriteString(string(t.Name)); err != nil {
5446 return err
5447 }
5448
5449 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
5450 if len("clone") > 1000000 {
5451 return xerrors.Errorf("Value in field \"clone\" was too long")
5452 }
5453
5454 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil {
5455 return err
5456 }
5457 if _, err := cw.WriteString(string("clone")); err != nil {
5458 return err
5459 }
5460
5461 if err := t.Clone.MarshalCBOR(cw); err != nil {
5462 return err
5463 }
5464
5465 // t.Engine (string) (string)
5466 if len("engine") > 1000000 {
5467 return xerrors.Errorf("Value in field \"engine\" was too long")
5468 }
5469
5470 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("engine"))); err != nil {
5471 return err
5472 }
5473 if _, err := cw.WriteString(string("engine")); err != nil {
5474 return err
5475 }
5476
5477 if len(t.Engine) > 1000000 {
5478 return xerrors.Errorf("Value in field t.Engine was too long")
5479 }
5480
5481 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Engine))); err != nil {
5482 return err
5483 }
5484 if _, err := cw.WriteString(string(t.Engine)); err != nil {
5485 return err
5486 }
5487 return nil
5488}
5489
5490func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) {
5491 *t = Pipeline_Workflow{}
5492
5493 cr := cbg.NewCborReader(r)
5494
5495 maj, extra, err := cr.ReadHeader()
5496 if err != nil {
5497 return err
5498 }
5499 defer func() {
5500 if err == io.EOF {
5501 err = io.ErrUnexpectedEOF
5502 }
5503 }()
5504
5505 if maj != cbg.MajMap {
5506 return fmt.Errorf("cbor input should be of type map")
5507 }
5508
5509 if extra > cbg.MaxLength {
5510 return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra)
5511 }
5512
5513 n := extra
5514
5515 nameBuf := make([]byte, 6)
5516 for i := uint64(0); i < n; i++ {
5517 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5518 if err != nil {
5519 return err
5520 }
5521
5522 if !ok {
5523 // Field doesn't exist on this type, so ignore it
5524 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5525 return err
5526 }
5527 continue
5528 }
5529
5530 switch string(nameBuf[:nameLen]) {
5531 // t.Raw (string) (string)
5532 case "raw":
5533
5534 {
5535 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5536 if err != nil {
5537 return err
5538 }
5539
5540 t.Raw = string(sval)
5541 }
5542 // t.Name (string) (string)
5543 case "name":
5544
5545 {
5546 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5547 if err != nil {
5548 return err
5549 }
5550
5551 t.Name = string(sval)
5552 }
5553 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
5554 case "clone":
5555
5556 {
5557
5558 b, err := cr.ReadByte()
5559 if err != nil {
5560 return err
5561 }
5562 if b != cbg.CborNull[0] {
5563 if err := cr.UnreadByte(); err != nil {
5564 return err
5565 }
5566 t.Clone = new(Pipeline_CloneOpts)
5567 if err := t.Clone.UnmarshalCBOR(cr); err != nil {
5568 return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err)
5569 }
5570 }
5571
5572 }
5573 // t.Engine (string) (string)
5574 case "engine":
5575
5576 {
5577 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5578 if err != nil {
5579 return err
5580 }
5581
5582 t.Engine = string(sval)
5583 }
5584
5585 default:
5586 // Field doesn't exist on this type, so ignore it
5587 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5588 return err
5589 }
5590 }
5591 }
5592
5593 return nil
5594}
5595func (t *PublicKey) MarshalCBOR(w io.Writer) error {
5596 if t == nil {
5597 _, err := w.Write(cbg.CborNull)
5598 return err
5599 }
5600
5601 cw := cbg.NewCborWriter(w)
5602
5603 if _, err := cw.Write([]byte{164}); err != nil {
5604 return err
5605 }
5606
5607 // t.Key (string) (string)
5608 if len("key") > 1000000 {
5609 return xerrors.Errorf("Value in field \"key\" was too long")
5610 }
5611
5612 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
5613 return err
5614 }
5615 if _, err := cw.WriteString(string("key")); err != nil {
5616 return err
5617 }
5618
5619 if len(t.Key) > 1000000 {
5620 return xerrors.Errorf("Value in field t.Key was too long")
5621 }
5622
5623 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
5624 return err
5625 }
5626 if _, err := cw.WriteString(string(t.Key)); err != nil {
5627 return err
5628 }
5629
5630 // t.Name (string) (string)
5631 if len("name") > 1000000 {
5632 return xerrors.Errorf("Value in field \"name\" was too long")
5633 }
5634
5635 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5636 return err
5637 }
5638 if _, err := cw.WriteString(string("name")); err != nil {
5639 return err
5640 }
5641
5642 if len(t.Name) > 1000000 {
5643 return xerrors.Errorf("Value in field t.Name was too long")
5644 }
5645
5646 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5647 return err
5648 }
5649 if _, err := cw.WriteString(string(t.Name)); err != nil {
5650 return err
5651 }
5652
5653 // t.LexiconTypeID (string) (string)
5654 if len("$type") > 1000000 {
5655 return xerrors.Errorf("Value in field \"$type\" was too long")
5656 }
5657
5658 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5659 return err
5660 }
5661 if _, err := cw.WriteString(string("$type")); err != nil {
5662 return err
5663 }
5664
5665 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil {
5666 return err
5667 }
5668 if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil {
5669 return err
5670 }
5671
5672 // t.CreatedAt (string) (string)
5673 if len("createdAt") > 1000000 {
5674 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5675 }
5676
5677 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5678 return err
5679 }
5680 if _, err := cw.WriteString(string("createdAt")); err != nil {
5681 return err
5682 }
5683
5684 if len(t.CreatedAt) > 1000000 {
5685 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5686 }
5687
5688 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5689 return err
5690 }
5691 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5692 return err
5693 }
5694 return nil
5695}
5696
5697func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) {
5698 *t = PublicKey{}
5699
5700 cr := cbg.NewCborReader(r)
5701
5702 maj, extra, err := cr.ReadHeader()
5703 if err != nil {
5704 return err
5705 }
5706 defer func() {
5707 if err == io.EOF {
5708 err = io.ErrUnexpectedEOF
5709 }
5710 }()
5711
5712 if maj != cbg.MajMap {
5713 return fmt.Errorf("cbor input should be of type map")
5714 }
5715
5716 if extra > cbg.MaxLength {
5717 return fmt.Errorf("PublicKey: map struct too large (%d)", extra)
5718 }
5719
5720 n := extra
5721
5722 nameBuf := make([]byte, 9)
5723 for i := uint64(0); i < n; i++ {
5724 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5725 if err != nil {
5726 return err
5727 }
5728
5729 if !ok {
5730 // Field doesn't exist on this type, so ignore it
5731 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5732 return err
5733 }
5734 continue
5735 }
5736
5737 switch string(nameBuf[:nameLen]) {
5738 // t.Key (string) (string)
5739 case "key":
5740
5741 {
5742 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5743 if err != nil {
5744 return err
5745 }
5746
5747 t.Key = string(sval)
5748 }
5749 // t.Name (string) (string)
5750 case "name":
5751
5752 {
5753 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5754 if err != nil {
5755 return err
5756 }
5757
5758 t.Name = string(sval)
5759 }
5760 // t.LexiconTypeID (string) (string)
5761 case "$type":
5762
5763 {
5764 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5765 if err != nil {
5766 return err
5767 }
5768
5769 t.LexiconTypeID = string(sval)
5770 }
5771 // t.CreatedAt (string) (string)
5772 case "createdAt":
5773
5774 {
5775 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5776 if err != nil {
5777 return err
5778 }
5779
5780 t.CreatedAt = string(sval)
5781 }
5782
5783 default:
5784 // Field doesn't exist on this type, so ignore it
5785 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5786 return err
5787 }
5788 }
5789 }
5790
5791 return nil
5792}
5793func (t *Repo) MarshalCBOR(w io.Writer) error {
5794 if t == nil {
5795 _, err := w.Write(cbg.CborNull)
5796 return err
5797 }
5798
5799 cw := cbg.NewCborWriter(w)
5800 fieldCount := 8
5801
5802 if t.Description == nil {
5803 fieldCount--
5804 }
5805
5806 if t.Source == nil {
5807 fieldCount--
5808 }
5809
5810 if t.Spindle == nil {
5811 fieldCount--
5812 }
5813
5814 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5815 return err
5816 }
5817
5818 // t.Knot (string) (string)
5819 if len("knot") > 1000000 {
5820 return xerrors.Errorf("Value in field \"knot\" was too long")
5821 }
5822
5823 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
5824 return err
5825 }
5826 if _, err := cw.WriteString(string("knot")); err != nil {
5827 return err
5828 }
5829
5830 if len(t.Knot) > 1000000 {
5831 return xerrors.Errorf("Value in field t.Knot was too long")
5832 }
5833
5834 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
5835 return err
5836 }
5837 if _, err := cw.WriteString(string(t.Knot)); err != nil {
5838 return err
5839 }
5840
5841 // t.Name (string) (string)
5842 if len("name") > 1000000 {
5843 return xerrors.Errorf("Value in field \"name\" was too long")
5844 }
5845
5846 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5847 return err
5848 }
5849 if _, err := cw.WriteString(string("name")); err != nil {
5850 return err
5851 }
5852
5853 if len(t.Name) > 1000000 {
5854 return xerrors.Errorf("Value in field t.Name was too long")
5855 }
5856
5857 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5858 return err
5859 }
5860 if _, err := cw.WriteString(string(t.Name)); err != nil {
5861 return err
5862 }
5863
5864 // t.LexiconTypeID (string) (string)
5865 if len("$type") > 1000000 {
5866 return xerrors.Errorf("Value in field \"$type\" was too long")
5867 }
5868
5869 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5870 return err
5871 }
5872 if _, err := cw.WriteString(string("$type")); err != nil {
5873 return err
5874 }
5875
5876 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil {
5877 return err
5878 }
5879 if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil {
5880 return err
5881 }
5882
5883 // t.Owner (string) (string)
5884 if len("owner") > 1000000 {
5885 return xerrors.Errorf("Value in field \"owner\" was too long")
5886 }
5887
5888 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
5889 return err
5890 }
5891 if _, err := cw.WriteString(string("owner")); err != nil {
5892 return err
5893 }
5894
5895 if len(t.Owner) > 1000000 {
5896 return xerrors.Errorf("Value in field t.Owner was too long")
5897 }
5898
5899 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {
5900 return err
5901 }
5902 if _, err := cw.WriteString(string(t.Owner)); err != nil {
5903 return err
5904 }
5905
5906 // t.Source (string) (string)
5907 if t.Source != nil {
5908
5909 if len("source") > 1000000 {
5910 return xerrors.Errorf("Value in field \"source\" was too long")
5911 }
5912
5913 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
5914 return err
5915 }
5916 if _, err := cw.WriteString(string("source")); err != nil {
5917 return err
5918 }
5919
5920 if t.Source == nil {
5921 if _, err := cw.Write(cbg.CborNull); err != nil {
5922 return err
5923 }
5924 } else {
5925 if len(*t.Source) > 1000000 {
5926 return xerrors.Errorf("Value in field t.Source was too long")
5927 }
5928
5929 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil {
5930 return err
5931 }
5932 if _, err := cw.WriteString(string(*t.Source)); err != nil {
5933 return err
5934 }
5935 }
5936 }
5937
5938 // t.Spindle (string) (string)
5939 if t.Spindle != nil {
5940
5941 if len("spindle") > 1000000 {
5942 return xerrors.Errorf("Value in field \"spindle\" was too long")
5943 }
5944
5945 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("spindle"))); err != nil {
5946 return err
5947 }
5948 if _, err := cw.WriteString(string("spindle")); err != nil {
5949 return err
5950 }
5951
5952 if t.Spindle == nil {
5953 if _, err := cw.Write(cbg.CborNull); err != nil {
5954 return err
5955 }
5956 } else {
5957 if len(*t.Spindle) > 1000000 {
5958 return xerrors.Errorf("Value in field t.Spindle was too long")
5959 }
5960
5961 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Spindle))); err != nil {
5962 return err
5963 }
5964 if _, err := cw.WriteString(string(*t.Spindle)); err != nil {
5965 return err
5966 }
5967 }
5968 }
5969
5970 // t.CreatedAt (string) (string)
5971 if len("createdAt") > 1000000 {
5972 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5973 }
5974
5975 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5976 return err
5977 }
5978 if _, err := cw.WriteString(string("createdAt")); err != nil {
5979 return err
5980 }
5981
5982 if len(t.CreatedAt) > 1000000 {
5983 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5984 }
5985
5986 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5987 return err
5988 }
5989 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5990 return err
5991 }
5992
5993 // t.Description (string) (string)
5994 if t.Description != nil {
5995
5996 if len("description") > 1000000 {
5997 return xerrors.Errorf("Value in field \"description\" was too long")
5998 }
5999
6000 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
6001 return err
6002 }
6003 if _, err := cw.WriteString(string("description")); err != nil {
6004 return err
6005 }
6006
6007 if t.Description == nil {
6008 if _, err := cw.Write(cbg.CborNull); err != nil {
6009 return err
6010 }
6011 } else {
6012 if len(*t.Description) > 1000000 {
6013 return xerrors.Errorf("Value in field t.Description was too long")
6014 }
6015
6016 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
6017 return err
6018 }
6019 if _, err := cw.WriteString(string(*t.Description)); err != nil {
6020 return err
6021 }
6022 }
6023 }
6024 return nil
6025}
6026
6027func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) {
6028 *t = Repo{}
6029
6030 cr := cbg.NewCborReader(r)
6031
6032 maj, extra, err := cr.ReadHeader()
6033 if err != nil {
6034 return err
6035 }
6036 defer func() {
6037 if err == io.EOF {
6038 err = io.ErrUnexpectedEOF
6039 }
6040 }()
6041
6042 if maj != cbg.MajMap {
6043 return fmt.Errorf("cbor input should be of type map")
6044 }
6045
6046 if extra > cbg.MaxLength {
6047 return fmt.Errorf("Repo: map struct too large (%d)", extra)
6048 }
6049
6050 n := extra
6051
6052 nameBuf := make([]byte, 11)
6053 for i := uint64(0); i < n; i++ {
6054 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6055 if err != nil {
6056 return err
6057 }
6058
6059 if !ok {
6060 // Field doesn't exist on this type, so ignore it
6061 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6062 return err
6063 }
6064 continue
6065 }
6066
6067 switch string(nameBuf[:nameLen]) {
6068 // t.Knot (string) (string)
6069 case "knot":
6070
6071 {
6072 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6073 if err != nil {
6074 return err
6075 }
6076
6077 t.Knot = string(sval)
6078 }
6079 // t.Name (string) (string)
6080 case "name":
6081
6082 {
6083 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6084 if err != nil {
6085 return err
6086 }
6087
6088 t.Name = string(sval)
6089 }
6090 // t.LexiconTypeID (string) (string)
6091 case "$type":
6092
6093 {
6094 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6095 if err != nil {
6096 return err
6097 }
6098
6099 t.LexiconTypeID = string(sval)
6100 }
6101 // t.Owner (string) (string)
6102 case "owner":
6103
6104 {
6105 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6106 if err != nil {
6107 return err
6108 }
6109
6110 t.Owner = string(sval)
6111 }
6112 // t.Source (string) (string)
6113 case "source":
6114
6115 {
6116 b, err := cr.ReadByte()
6117 if err != nil {
6118 return err
6119 }
6120 if b != cbg.CborNull[0] {
6121 if err := cr.UnreadByte(); err != nil {
6122 return err
6123 }
6124
6125 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6126 if err != nil {
6127 return err
6128 }
6129
6130 t.Source = (*string)(&sval)
6131 }
6132 }
6133 // t.Spindle (string) (string)
6134 case "spindle":
6135
6136 {
6137 b, err := cr.ReadByte()
6138 if err != nil {
6139 return err
6140 }
6141 if b != cbg.CborNull[0] {
6142 if err := cr.UnreadByte(); err != nil {
6143 return err
6144 }
6145
6146 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6147 if err != nil {
6148 return err
6149 }
6150
6151 t.Spindle = (*string)(&sval)
6152 }
6153 }
6154 // t.CreatedAt (string) (string)
6155 case "createdAt":
6156
6157 {
6158 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6159 if err != nil {
6160 return err
6161 }
6162
6163 t.CreatedAt = string(sval)
6164 }
6165 // t.Description (string) (string)
6166 case "description":
6167
6168 {
6169 b, err := cr.ReadByte()
6170 if err != nil {
6171 return err
6172 }
6173 if b != cbg.CborNull[0] {
6174 if err := cr.UnreadByte(); err != nil {
6175 return err
6176 }
6177
6178 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6179 if err != nil {
6180 return err
6181 }
6182
6183 t.Description = (*string)(&sval)
6184 }
6185 }
6186
6187 default:
6188 // Field doesn't exist on this type, so ignore it
6189 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6190 return err
6191 }
6192 }
6193 }
6194
6195 return nil
6196}
6197func (t *RepoArtifact) MarshalCBOR(w io.Writer) error {
6198 if t == nil {
6199 _, err := w.Write(cbg.CborNull)
6200 return err
6201 }
6202
6203 cw := cbg.NewCborWriter(w)
6204 fieldCount := 6
6205
6206 if t.Tag == nil {
6207 fieldCount--
6208 }
6209
6210 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6211 return err
6212 }
6213
6214 // t.Tag (util.LexBytes) (slice)
6215 if t.Tag != nil {
6216
6217 if len("tag") > 1000000 {
6218 return xerrors.Errorf("Value in field \"tag\" was too long")
6219 }
6220
6221 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tag"))); err != nil {
6222 return err
6223 }
6224 if _, err := cw.WriteString(string("tag")); err != nil {
6225 return err
6226 }
6227
6228 if len(t.Tag) > 2097152 {
6229 return xerrors.Errorf("Byte array in field t.Tag was too long")
6230 }
6231
6232 if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Tag))); err != nil {
6233 return err
6234 }
6235
6236 if _, err := cw.Write(t.Tag); err != nil {
6237 return err
6238 }
6239
6240 }
6241
6242 // t.Name (string) (string)
6243 if len("name") > 1000000 {
6244 return xerrors.Errorf("Value in field \"name\" was too long")
6245 }
6246
6247 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
6248 return err
6249 }
6250 if _, err := cw.WriteString(string("name")); err != nil {
6251 return err
6252 }
6253
6254 if len(t.Name) > 1000000 {
6255 return xerrors.Errorf("Value in field t.Name was too long")
6256 }
6257
6258 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
6259 return err
6260 }
6261 if _, err := cw.WriteString(string(t.Name)); err != nil {
6262 return err
6263 }
6264
6265 // t.Repo (string) (string)
6266 if len("repo") > 1000000 {
6267 return xerrors.Errorf("Value in field \"repo\" was too long")
6268 }
6269
6270 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6271 return err
6272 }
6273 if _, err := cw.WriteString(string("repo")); err != nil {
6274 return err
6275 }
6276
6277 if len(t.Repo) > 1000000 {
6278 return xerrors.Errorf("Value in field t.Repo was too long")
6279 }
6280
6281 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
6282 return err
6283 }
6284 if _, err := cw.WriteString(string(t.Repo)); err != nil {
6285 return err
6286 }
6287
6288 // t.LexiconTypeID (string) (string)
6289 if len("$type") > 1000000 {
6290 return xerrors.Errorf("Value in field \"$type\" was too long")
6291 }
6292
6293 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6294 return err
6295 }
6296 if _, err := cw.WriteString(string("$type")); err != nil {
6297 return err
6298 }
6299
6300 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.artifact"))); err != nil {
6301 return err
6302 }
6303 if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil {
6304 return err
6305 }
6306
6307 // t.Artifact (util.LexBlob) (struct)
6308 if len("artifact") > 1000000 {
6309 return xerrors.Errorf("Value in field \"artifact\" was too long")
6310 }
6311
6312 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("artifact"))); err != nil {
6313 return err
6314 }
6315 if _, err := cw.WriteString(string("artifact")); err != nil {
6316 return err
6317 }
6318
6319 if err := t.Artifact.MarshalCBOR(cw); err != nil {
6320 return err
6321 }
6322
6323 // t.CreatedAt (string) (string)
6324 if len("createdAt") > 1000000 {
6325 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6326 }
6327
6328 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6329 return err
6330 }
6331 if _, err := cw.WriteString(string("createdAt")); err != nil {
6332 return err
6333 }
6334
6335 if len(t.CreatedAt) > 1000000 {
6336 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6337 }
6338
6339 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6340 return err
6341 }
6342 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6343 return err
6344 }
6345 return nil
6346}
6347
6348func (t *RepoArtifact) UnmarshalCBOR(r io.Reader) (err error) {
6349 *t = RepoArtifact{}
6350
6351 cr := cbg.NewCborReader(r)
6352
6353 maj, extra, err := cr.ReadHeader()
6354 if err != nil {
6355 return err
6356 }
6357 defer func() {
6358 if err == io.EOF {
6359 err = io.ErrUnexpectedEOF
6360 }
6361 }()
6362
6363 if maj != cbg.MajMap {
6364 return fmt.Errorf("cbor input should be of type map")
6365 }
6366
6367 if extra > cbg.MaxLength {
6368 return fmt.Errorf("RepoArtifact: map struct too large (%d)", extra)
6369 }
6370
6371 n := extra
6372
6373 nameBuf := make([]byte, 9)
6374 for i := uint64(0); i < n; i++ {
6375 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6376 if err != nil {
6377 return err
6378 }
6379
6380 if !ok {
6381 // Field doesn't exist on this type, so ignore it
6382 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6383 return err
6384 }
6385 continue
6386 }
6387
6388 switch string(nameBuf[:nameLen]) {
6389 // t.Tag (util.LexBytes) (slice)
6390 case "tag":
6391
6392 maj, extra, err = cr.ReadHeader()
6393 if err != nil {
6394 return err
6395 }
6396
6397 if extra > 2097152 {
6398 return fmt.Errorf("t.Tag: byte array too large (%d)", extra)
6399 }
6400 if maj != cbg.MajByteString {
6401 return fmt.Errorf("expected byte array")
6402 }
6403
6404 if extra > 0 {
6405 t.Tag = make([]uint8, extra)
6406 }
6407
6408 if _, err := io.ReadFull(cr, t.Tag); err != nil {
6409 return err
6410 }
6411
6412 // t.Name (string) (string)
6413 case "name":
6414
6415 {
6416 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6417 if err != nil {
6418 return err
6419 }
6420
6421 t.Name = string(sval)
6422 }
6423 // t.Repo (string) (string)
6424 case "repo":
6425
6426 {
6427 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6428 if err != nil {
6429 return err
6430 }
6431
6432 t.Repo = string(sval)
6433 }
6434 // t.LexiconTypeID (string) (string)
6435 case "$type":
6436
6437 {
6438 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6439 if err != nil {
6440 return err
6441 }
6442
6443 t.LexiconTypeID = string(sval)
6444 }
6445 // t.Artifact (util.LexBlob) (struct)
6446 case "artifact":
6447
6448 {
6449
6450 b, err := cr.ReadByte()
6451 if err != nil {
6452 return err
6453 }
6454 if b != cbg.CborNull[0] {
6455 if err := cr.UnreadByte(); err != nil {
6456 return err
6457 }
6458 t.Artifact = new(util.LexBlob)
6459 if err := t.Artifact.UnmarshalCBOR(cr); err != nil {
6460 return xerrors.Errorf("unmarshaling t.Artifact pointer: %w", err)
6461 }
6462 }
6463
6464 }
6465 // t.CreatedAt (string) (string)
6466 case "createdAt":
6467
6468 {
6469 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6470 if err != nil {
6471 return err
6472 }
6473
6474 t.CreatedAt = string(sval)
6475 }
6476
6477 default:
6478 // Field doesn't exist on this type, so ignore it
6479 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6480 return err
6481 }
6482 }
6483 }
6484
6485 return nil
6486}
6487func (t *RepoCollaborator) MarshalCBOR(w io.Writer) error {
6488 if t == nil {
6489 _, err := w.Write(cbg.CborNull)
6490 return err
6491 }
6492
6493 cw := cbg.NewCborWriter(w)
6494
6495 if _, err := cw.Write([]byte{164}); err != nil {
6496 return err
6497 }
6498
6499 // t.Repo (string) (string)
6500 if len("repo") > 1000000 {
6501 return xerrors.Errorf("Value in field \"repo\" was too long")
6502 }
6503
6504 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6505 return err
6506 }
6507 if _, err := cw.WriteString(string("repo")); err != nil {
6508 return err
6509 }
6510
6511 if len(t.Repo) > 1000000 {
6512 return xerrors.Errorf("Value in field t.Repo was too long")
6513 }
6514
6515 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
6516 return err
6517 }
6518 if _, err := cw.WriteString(string(t.Repo)); err != nil {
6519 return err
6520 }
6521
6522 // t.LexiconTypeID (string) (string)
6523 if len("$type") > 1000000 {
6524 return xerrors.Errorf("Value in field \"$type\" was too long")
6525 }
6526
6527 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6528 return err
6529 }
6530 if _, err := cw.WriteString(string("$type")); err != nil {
6531 return err
6532 }
6533
6534 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.collaborator"))); err != nil {
6535 return err
6536 }
6537 if _, err := cw.WriteString(string("sh.tangled.repo.collaborator")); err != nil {
6538 return err
6539 }
6540
6541 // t.Subject (string) (string)
6542 if len("subject") > 1000000 {
6543 return xerrors.Errorf("Value in field \"subject\" was too long")
6544 }
6545
6546 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
6547 return err
6548 }
6549 if _, err := cw.WriteString(string("subject")); err != nil {
6550 return err
6551 }
6552
6553 if len(t.Subject) > 1000000 {
6554 return xerrors.Errorf("Value in field t.Subject was too long")
6555 }
6556
6557 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
6558 return err
6559 }
6560 if _, err := cw.WriteString(string(t.Subject)); err != nil {
6561 return err
6562 }
6563
6564 // t.CreatedAt (string) (string)
6565 if len("createdAt") > 1000000 {
6566 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6567 }
6568
6569 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6570 return err
6571 }
6572 if _, err := cw.WriteString(string("createdAt")); err != nil {
6573 return err
6574 }
6575
6576 if len(t.CreatedAt) > 1000000 {
6577 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6578 }
6579
6580 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6581 return err
6582 }
6583 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6584 return err
6585 }
6586 return nil
6587}
6588
6589func (t *RepoCollaborator) UnmarshalCBOR(r io.Reader) (err error) {
6590 *t = RepoCollaborator{}
6591
6592 cr := cbg.NewCborReader(r)
6593
6594 maj, extra, err := cr.ReadHeader()
6595 if err != nil {
6596 return err
6597 }
6598 defer func() {
6599 if err == io.EOF {
6600 err = io.ErrUnexpectedEOF
6601 }
6602 }()
6603
6604 if maj != cbg.MajMap {
6605 return fmt.Errorf("cbor input should be of type map")
6606 }
6607
6608 if extra > cbg.MaxLength {
6609 return fmt.Errorf("RepoCollaborator: map struct too large (%d)", extra)
6610 }
6611
6612 n := extra
6613
6614 nameBuf := make([]byte, 9)
6615 for i := uint64(0); i < n; i++ {
6616 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6617 if err != nil {
6618 return err
6619 }
6620
6621 if !ok {
6622 // Field doesn't exist on this type, so ignore it
6623 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6624 return err
6625 }
6626 continue
6627 }
6628
6629 switch string(nameBuf[:nameLen]) {
6630 // t.Repo (string) (string)
6631 case "repo":
6632
6633 {
6634 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6635 if err != nil {
6636 return err
6637 }
6638
6639 t.Repo = string(sval)
6640 }
6641 // t.LexiconTypeID (string) (string)
6642 case "$type":
6643
6644 {
6645 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6646 if err != nil {
6647 return err
6648 }
6649
6650 t.LexiconTypeID = string(sval)
6651 }
6652 // t.Subject (string) (string)
6653 case "subject":
6654
6655 {
6656 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6657 if err != nil {
6658 return err
6659 }
6660
6661 t.Subject = string(sval)
6662 }
6663 // t.CreatedAt (string) (string)
6664 case "createdAt":
6665
6666 {
6667 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6668 if err != nil {
6669 return err
6670 }
6671
6672 t.CreatedAt = string(sval)
6673 }
6674
6675 default:
6676 // Field doesn't exist on this type, so ignore it
6677 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6678 return err
6679 }
6680 }
6681 }
6682
6683 return nil
6684}
6685func (t *RepoIssue) MarshalCBOR(w io.Writer) error {
6686 if t == nil {
6687 _, err := w.Write(cbg.CborNull)
6688 return err
6689 }
6690
6691 cw := cbg.NewCborWriter(w)
6692 fieldCount := 5
6693
6694 if t.Body == nil {
6695 fieldCount--
6696 }
6697
6698 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6699 return err
6700 }
6701
6702 // t.Body (string) (string)
6703 if t.Body != nil {
6704
6705 if len("body") > 1000000 {
6706 return xerrors.Errorf("Value in field \"body\" was too long")
6707 }
6708
6709 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
6710 return err
6711 }
6712 if _, err := cw.WriteString(string("body")); err != nil {
6713 return err
6714 }
6715
6716 if t.Body == nil {
6717 if _, err := cw.Write(cbg.CborNull); err != nil {
6718 return err
6719 }
6720 } else {
6721 if len(*t.Body) > 1000000 {
6722 return xerrors.Errorf("Value in field t.Body was too long")
6723 }
6724
6725 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
6726 return err
6727 }
6728 if _, err := cw.WriteString(string(*t.Body)); err != nil {
6729 return err
6730 }
6731 }
6732 }
6733
6734 // t.Repo (string) (string)
6735 if len("repo") > 1000000 {
6736 return xerrors.Errorf("Value in field \"repo\" was too long")
6737 }
6738
6739 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6740 return err
6741 }
6742 if _, err := cw.WriteString(string("repo")); err != nil {
6743 return err
6744 }
6745
6746 if len(t.Repo) > 1000000 {
6747 return xerrors.Errorf("Value in field t.Repo was too long")
6748 }
6749
6750 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
6751 return err
6752 }
6753 if _, err := cw.WriteString(string(t.Repo)); err != nil {
6754 return err
6755 }
6756
6757 // t.LexiconTypeID (string) (string)
6758 if len("$type") > 1000000 {
6759 return xerrors.Errorf("Value in field \"$type\" was too long")
6760 }
6761
6762 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6763 return err
6764 }
6765 if _, err := cw.WriteString(string("$type")); err != nil {
6766 return err
6767 }
6768
6769 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil {
6770 return err
6771 }
6772 if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil {
6773 return err
6774 }
6775
6776 // t.Title (string) (string)
6777 if len("title") > 1000000 {
6778 return xerrors.Errorf("Value in field \"title\" was too long")
6779 }
6780
6781 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
6782 return err
6783 }
6784 if _, err := cw.WriteString(string("title")); err != nil {
6785 return err
6786 }
6787
6788 if len(t.Title) > 1000000 {
6789 return xerrors.Errorf("Value in field t.Title was too long")
6790 }
6791
6792 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
6793 return err
6794 }
6795 if _, err := cw.WriteString(string(t.Title)); err != nil {
6796 return err
6797 }
6798
6799 // t.CreatedAt (string) (string)
6800 if len("createdAt") > 1000000 {
6801 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6802 }
6803
6804 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6805 return err
6806 }
6807 if _, err := cw.WriteString(string("createdAt")); err != nil {
6808 return err
6809 }
6810
6811 if len(t.CreatedAt) > 1000000 {
6812 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6813 }
6814
6815 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6816 return err
6817 }
6818 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6819 return err
6820 }
6821 return nil
6822}
6823
6824func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) {
6825 *t = RepoIssue{}
6826
6827 cr := cbg.NewCborReader(r)
6828
6829 maj, extra, err := cr.ReadHeader()
6830 if err != nil {
6831 return err
6832 }
6833 defer func() {
6834 if err == io.EOF {
6835 err = io.ErrUnexpectedEOF
6836 }
6837 }()
6838
6839 if maj != cbg.MajMap {
6840 return fmt.Errorf("cbor input should be of type map")
6841 }
6842
6843 if extra > cbg.MaxLength {
6844 return fmt.Errorf("RepoIssue: map struct too large (%d)", extra)
6845 }
6846
6847 n := extra
6848
6849 nameBuf := make([]byte, 9)
6850 for i := uint64(0); i < n; i++ {
6851 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6852 if err != nil {
6853 return err
6854 }
6855
6856 if !ok {
6857 // Field doesn't exist on this type, so ignore it
6858 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6859 return err
6860 }
6861 continue
6862 }
6863
6864 switch string(nameBuf[:nameLen]) {
6865 // t.Body (string) (string)
6866 case "body":
6867
6868 {
6869 b, err := cr.ReadByte()
6870 if err != nil {
6871 return err
6872 }
6873 if b != cbg.CborNull[0] {
6874 if err := cr.UnreadByte(); err != nil {
6875 return err
6876 }
6877
6878 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6879 if err != nil {
6880 return err
6881 }
6882
6883 t.Body = (*string)(&sval)
6884 }
6885 }
6886 // t.Repo (string) (string)
6887 case "repo":
6888
6889 {
6890 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6891 if err != nil {
6892 return err
6893 }
6894
6895 t.Repo = string(sval)
6896 }
6897 // t.LexiconTypeID (string) (string)
6898 case "$type":
6899
6900 {
6901 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6902 if err != nil {
6903 return err
6904 }
6905
6906 t.LexiconTypeID = string(sval)
6907 }
6908 // t.Title (string) (string)
6909 case "title":
6910
6911 {
6912 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6913 if err != nil {
6914 return err
6915 }
6916
6917 t.Title = string(sval)
6918 }
6919 // t.CreatedAt (string) (string)
6920 case "createdAt":
6921
6922 {
6923 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6924 if err != nil {
6925 return err
6926 }
6927
6928 t.CreatedAt = string(sval)
6929 }
6930
6931 default:
6932 // Field doesn't exist on this type, so ignore it
6933 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6934 return err
6935 }
6936 }
6937 }
6938
6939 return nil
6940}
6941func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error {
6942 if t == nil {
6943 _, err := w.Write(cbg.CborNull)
6944 return err
6945 }
6946
6947 cw := cbg.NewCborWriter(w)
6948 fieldCount := 5
6949
6950 if t.ReplyTo == nil {
6951 fieldCount--
6952 }
6953
6954 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6955 return err
6956 }
6957
6958 // t.Body (string) (string)
6959 if len("body") > 1000000 {
6960 return xerrors.Errorf("Value in field \"body\" was too long")
6961 }
6962
6963 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
6964 return err
6965 }
6966 if _, err := cw.WriteString(string("body")); err != nil {
6967 return err
6968 }
6969
6970 if len(t.Body) > 1000000 {
6971 return xerrors.Errorf("Value in field t.Body was too long")
6972 }
6973
6974 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
6975 return err
6976 }
6977 if _, err := cw.WriteString(string(t.Body)); err != nil {
6978 return err
6979 }
6980
6981 // t.LexiconTypeID (string) (string)
6982 if len("$type") > 1000000 {
6983 return xerrors.Errorf("Value in field \"$type\" was too long")
6984 }
6985
6986 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6987 return err
6988 }
6989 if _, err := cw.WriteString(string("$type")); err != nil {
6990 return err
6991 }
6992
6993 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil {
6994 return err
6995 }
6996 if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil {
6997 return err
6998 }
6999
7000 // t.Issue (string) (string)
7001 if len("issue") > 1000000 {
7002 return xerrors.Errorf("Value in field \"issue\" was too long")
7003 }
7004
7005 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
7006 return err
7007 }
7008 if _, err := cw.WriteString(string("issue")); err != nil {
7009 return err
7010 }
7011
7012 if len(t.Issue) > 1000000 {
7013 return xerrors.Errorf("Value in field t.Issue was too long")
7014 }
7015
7016 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
7017 return err
7018 }
7019 if _, err := cw.WriteString(string(t.Issue)); err != nil {
7020 return err
7021 }
7022
7023 // t.ReplyTo (string) (string)
7024 if t.ReplyTo != nil {
7025
7026 if len("replyTo") > 1000000 {
7027 return xerrors.Errorf("Value in field \"replyTo\" was too long")
7028 }
7029
7030 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("replyTo"))); err != nil {
7031 return err
7032 }
7033 if _, err := cw.WriteString(string("replyTo")); err != nil {
7034 return err
7035 }
7036
7037 if t.ReplyTo == nil {
7038 if _, err := cw.Write(cbg.CborNull); err != nil {
7039 return err
7040 }
7041 } else {
7042 if len(*t.ReplyTo) > 1000000 {
7043 return xerrors.Errorf("Value in field t.ReplyTo was too long")
7044 }
7045
7046 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ReplyTo))); err != nil {
7047 return err
7048 }
7049 if _, err := cw.WriteString(string(*t.ReplyTo)); err != nil {
7050 return err
7051 }
7052 }
7053 }
7054
7055 // t.CreatedAt (string) (string)
7056 if len("createdAt") > 1000000 {
7057 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7058 }
7059
7060 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7061 return err
7062 }
7063 if _, err := cw.WriteString(string("createdAt")); err != nil {
7064 return err
7065 }
7066
7067 if len(t.CreatedAt) > 1000000 {
7068 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7069 }
7070
7071 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7072 return err
7073 }
7074 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7075 return err
7076 }
7077 return nil
7078}
7079
7080func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) {
7081 *t = RepoIssueComment{}
7082
7083 cr := cbg.NewCborReader(r)
7084
7085 maj, extra, err := cr.ReadHeader()
7086 if err != nil {
7087 return err
7088 }
7089 defer func() {
7090 if err == io.EOF {
7091 err = io.ErrUnexpectedEOF
7092 }
7093 }()
7094
7095 if maj != cbg.MajMap {
7096 return fmt.Errorf("cbor input should be of type map")
7097 }
7098
7099 if extra > cbg.MaxLength {
7100 return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra)
7101 }
7102
7103 n := extra
7104
7105 nameBuf := make([]byte, 9)
7106 for i := uint64(0); i < n; i++ {
7107 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7108 if err != nil {
7109 return err
7110 }
7111
7112 if !ok {
7113 // Field doesn't exist on this type, so ignore it
7114 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7115 return err
7116 }
7117 continue
7118 }
7119
7120 switch string(nameBuf[:nameLen]) {
7121 // t.Body (string) (string)
7122 case "body":
7123
7124 {
7125 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7126 if err != nil {
7127 return err
7128 }
7129
7130 t.Body = string(sval)
7131 }
7132 // t.LexiconTypeID (string) (string)
7133 case "$type":
7134
7135 {
7136 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7137 if err != nil {
7138 return err
7139 }
7140
7141 t.LexiconTypeID = string(sval)
7142 }
7143 // t.Issue (string) (string)
7144 case "issue":
7145
7146 {
7147 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7148 if err != nil {
7149 return err
7150 }
7151
7152 t.Issue = string(sval)
7153 }
7154 // t.ReplyTo (string) (string)
7155 case "replyTo":
7156
7157 {
7158 b, err := cr.ReadByte()
7159 if err != nil {
7160 return err
7161 }
7162 if b != cbg.CborNull[0] {
7163 if err := cr.UnreadByte(); err != nil {
7164 return err
7165 }
7166
7167 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7168 if err != nil {
7169 return err
7170 }
7171
7172 t.ReplyTo = (*string)(&sval)
7173 }
7174 }
7175 // t.CreatedAt (string) (string)
7176 case "createdAt":
7177
7178 {
7179 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7180 if err != nil {
7181 return err
7182 }
7183
7184 t.CreatedAt = string(sval)
7185 }
7186
7187 default:
7188 // Field doesn't exist on this type, so ignore it
7189 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7190 return err
7191 }
7192 }
7193 }
7194
7195 return nil
7196}
7197func (t *RepoIssueState) MarshalCBOR(w io.Writer) error {
7198 if t == nil {
7199 _, err := w.Write(cbg.CborNull)
7200 return err
7201 }
7202
7203 cw := cbg.NewCborWriter(w)
7204
7205 if _, err := cw.Write([]byte{163}); err != nil {
7206 return err
7207 }
7208
7209 // t.LexiconTypeID (string) (string)
7210 if len("$type") > 1000000 {
7211 return xerrors.Errorf("Value in field \"$type\" was too long")
7212 }
7213
7214 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7215 return err
7216 }
7217 if _, err := cw.WriteString(string("$type")); err != nil {
7218 return err
7219 }
7220
7221 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil {
7222 return err
7223 }
7224 if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil {
7225 return err
7226 }
7227
7228 // t.Issue (string) (string)
7229 if len("issue") > 1000000 {
7230 return xerrors.Errorf("Value in field \"issue\" was too long")
7231 }
7232
7233 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
7234 return err
7235 }
7236 if _, err := cw.WriteString(string("issue")); err != nil {
7237 return err
7238 }
7239
7240 if len(t.Issue) > 1000000 {
7241 return xerrors.Errorf("Value in field t.Issue was too long")
7242 }
7243
7244 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
7245 return err
7246 }
7247 if _, err := cw.WriteString(string(t.Issue)); err != nil {
7248 return err
7249 }
7250
7251 // t.State (string) (string)
7252 if len("state") > 1000000 {
7253 return xerrors.Errorf("Value in field \"state\" was too long")
7254 }
7255
7256 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil {
7257 return err
7258 }
7259 if _, err := cw.WriteString(string("state")); err != nil {
7260 return err
7261 }
7262
7263 if len(t.State) > 1000000 {
7264 return xerrors.Errorf("Value in field t.State was too long")
7265 }
7266
7267 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil {
7268 return err
7269 }
7270 if _, err := cw.WriteString(string(t.State)); err != nil {
7271 return err
7272 }
7273 return nil
7274}
7275
7276func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) {
7277 *t = RepoIssueState{}
7278
7279 cr := cbg.NewCborReader(r)
7280
7281 maj, extra, err := cr.ReadHeader()
7282 if err != nil {
7283 return err
7284 }
7285 defer func() {
7286 if err == io.EOF {
7287 err = io.ErrUnexpectedEOF
7288 }
7289 }()
7290
7291 if maj != cbg.MajMap {
7292 return fmt.Errorf("cbor input should be of type map")
7293 }
7294
7295 if extra > cbg.MaxLength {
7296 return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra)
7297 }
7298
7299 n := extra
7300
7301 nameBuf := make([]byte, 5)
7302 for i := uint64(0); i < n; i++ {
7303 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7304 if err != nil {
7305 return err
7306 }
7307
7308 if !ok {
7309 // Field doesn't exist on this type, so ignore it
7310 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7311 return err
7312 }
7313 continue
7314 }
7315
7316 switch string(nameBuf[:nameLen]) {
7317 // t.LexiconTypeID (string) (string)
7318 case "$type":
7319
7320 {
7321 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7322 if err != nil {
7323 return err
7324 }
7325
7326 t.LexiconTypeID = string(sval)
7327 }
7328 // t.Issue (string) (string)
7329 case "issue":
7330
7331 {
7332 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7333 if err != nil {
7334 return err
7335 }
7336
7337 t.Issue = string(sval)
7338 }
7339 // t.State (string) (string)
7340 case "state":
7341
7342 {
7343 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7344 if err != nil {
7345 return err
7346 }
7347
7348 t.State = string(sval)
7349 }
7350
7351 default:
7352 // Field doesn't exist on this type, so ignore it
7353 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7354 return err
7355 }
7356 }
7357 }
7358
7359 return nil
7360}
7361func (t *RepoPull) MarshalCBOR(w io.Writer) error {
7362 if t == nil {
7363 _, err := w.Write(cbg.CborNull)
7364 return err
7365 }
7366
7367 cw := cbg.NewCborWriter(w)
7368 fieldCount := 7
7369
7370 if t.Body == nil {
7371 fieldCount--
7372 }
7373
7374 if t.Source == nil {
7375 fieldCount--
7376 }
7377
7378 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7379 return err
7380 }
7381
7382 // t.Body (string) (string)
7383 if t.Body != nil {
7384
7385 if len("body") > 1000000 {
7386 return xerrors.Errorf("Value in field \"body\" was too long")
7387 }
7388
7389 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
7390 return err
7391 }
7392 if _, err := cw.WriteString(string("body")); err != nil {
7393 return err
7394 }
7395
7396 if t.Body == nil {
7397 if _, err := cw.Write(cbg.CborNull); err != nil {
7398 return err
7399 }
7400 } else {
7401 if len(*t.Body) > 1000000 {
7402 return xerrors.Errorf("Value in field t.Body was too long")
7403 }
7404
7405 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
7406 return err
7407 }
7408 if _, err := cw.WriteString(string(*t.Body)); err != nil {
7409 return err
7410 }
7411 }
7412 }
7413
7414 // t.LexiconTypeID (string) (string)
7415 if len("$type") > 1000000 {
7416 return xerrors.Errorf("Value in field \"$type\" was too long")
7417 }
7418
7419 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7420 return err
7421 }
7422 if _, err := cw.WriteString(string("$type")); err != nil {
7423 return err
7424 }
7425
7426 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil {
7427 return err
7428 }
7429 if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil {
7430 return err
7431 }
7432
7433 // t.Patch (string) (string)
7434 if len("patch") > 1000000 {
7435 return xerrors.Errorf("Value in field \"patch\" was too long")
7436 }
7437
7438 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil {
7439 return err
7440 }
7441 if _, err := cw.WriteString(string("patch")); err != nil {
7442 return err
7443 }
7444
7445 if len(t.Patch) > 1000000 {
7446 return xerrors.Errorf("Value in field t.Patch was too long")
7447 }
7448
7449 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Patch))); err != nil {
7450 return err
7451 }
7452 if _, err := cw.WriteString(string(t.Patch)); err != nil {
7453 return err
7454 }
7455
7456 // t.Title (string) (string)
7457 if len("title") > 1000000 {
7458 return xerrors.Errorf("Value in field \"title\" was too long")
7459 }
7460
7461 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
7462 return err
7463 }
7464 if _, err := cw.WriteString(string("title")); err != nil {
7465 return err
7466 }
7467
7468 if len(t.Title) > 1000000 {
7469 return xerrors.Errorf("Value in field t.Title was too long")
7470 }
7471
7472 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
7473 return err
7474 }
7475 if _, err := cw.WriteString(string(t.Title)); err != nil {
7476 return err
7477 }
7478
7479 // t.Source (tangled.RepoPull_Source) (struct)
7480 if t.Source != nil {
7481
7482 if len("source") > 1000000 {
7483 return xerrors.Errorf("Value in field \"source\" was too long")
7484 }
7485
7486 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
7487 return err
7488 }
7489 if _, err := cw.WriteString(string("source")); err != nil {
7490 return err
7491 }
7492
7493 if err := t.Source.MarshalCBOR(cw); err != nil {
7494 return err
7495 }
7496 }
7497
7498 // t.Target (tangled.RepoPull_Target) (struct)
7499 if len("target") > 1000000 {
7500 return xerrors.Errorf("Value in field \"target\" was too long")
7501 }
7502
7503 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("target"))); err != nil {
7504 return err
7505 }
7506 if _, err := cw.WriteString(string("target")); err != nil {
7507 return err
7508 }
7509
7510 if err := t.Target.MarshalCBOR(cw); err != nil {
7511 return err
7512 }
7513
7514 // t.CreatedAt (string) (string)
7515 if len("createdAt") > 1000000 {
7516 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7517 }
7518
7519 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7520 return err
7521 }
7522 if _, err := cw.WriteString(string("createdAt")); err != nil {
7523 return err
7524 }
7525
7526 if len(t.CreatedAt) > 1000000 {
7527 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7528 }
7529
7530 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7531 return err
7532 }
7533 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7534 return err
7535 }
7536 return nil
7537}
7538
7539func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) {
7540 *t = RepoPull{}
7541
7542 cr := cbg.NewCborReader(r)
7543
7544 maj, extra, err := cr.ReadHeader()
7545 if err != nil {
7546 return err
7547 }
7548 defer func() {
7549 if err == io.EOF {
7550 err = io.ErrUnexpectedEOF
7551 }
7552 }()
7553
7554 if maj != cbg.MajMap {
7555 return fmt.Errorf("cbor input should be of type map")
7556 }
7557
7558 if extra > cbg.MaxLength {
7559 return fmt.Errorf("RepoPull: map struct too large (%d)", extra)
7560 }
7561
7562 n := extra
7563
7564 nameBuf := make([]byte, 9)
7565 for i := uint64(0); i < n; i++ {
7566 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7567 if err != nil {
7568 return err
7569 }
7570
7571 if !ok {
7572 // Field doesn't exist on this type, so ignore it
7573 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7574 return err
7575 }
7576 continue
7577 }
7578
7579 switch string(nameBuf[:nameLen]) {
7580 // t.Body (string) (string)
7581 case "body":
7582
7583 {
7584 b, err := cr.ReadByte()
7585 if err != nil {
7586 return err
7587 }
7588 if b != cbg.CborNull[0] {
7589 if err := cr.UnreadByte(); err != nil {
7590 return err
7591 }
7592
7593 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7594 if err != nil {
7595 return err
7596 }
7597
7598 t.Body = (*string)(&sval)
7599 }
7600 }
7601 // t.LexiconTypeID (string) (string)
7602 case "$type":
7603
7604 {
7605 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7606 if err != nil {
7607 return err
7608 }
7609
7610 t.LexiconTypeID = string(sval)
7611 }
7612 // t.Patch (string) (string)
7613 case "patch":
7614
7615 {
7616 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7617 if err != nil {
7618 return err
7619 }
7620
7621 t.Patch = string(sval)
7622 }
7623 // t.Title (string) (string)
7624 case "title":
7625
7626 {
7627 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7628 if err != nil {
7629 return err
7630 }
7631
7632 t.Title = string(sval)
7633 }
7634 // t.Source (tangled.RepoPull_Source) (struct)
7635 case "source":
7636
7637 {
7638
7639 b, err := cr.ReadByte()
7640 if err != nil {
7641 return err
7642 }
7643 if b != cbg.CborNull[0] {
7644 if err := cr.UnreadByte(); err != nil {
7645 return err
7646 }
7647 t.Source = new(RepoPull_Source)
7648 if err := t.Source.UnmarshalCBOR(cr); err != nil {
7649 return xerrors.Errorf("unmarshaling t.Source pointer: %w", err)
7650 }
7651 }
7652
7653 }
7654 // t.Target (tangled.RepoPull_Target) (struct)
7655 case "target":
7656
7657 {
7658
7659 b, err := cr.ReadByte()
7660 if err != nil {
7661 return err
7662 }
7663 if b != cbg.CborNull[0] {
7664 if err := cr.UnreadByte(); err != nil {
7665 return err
7666 }
7667 t.Target = new(RepoPull_Target)
7668 if err := t.Target.UnmarshalCBOR(cr); err != nil {
7669 return xerrors.Errorf("unmarshaling t.Target pointer: %w", err)
7670 }
7671 }
7672
7673 }
7674 // t.CreatedAt (string) (string)
7675 case "createdAt":
7676
7677 {
7678 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7679 if err != nil {
7680 return err
7681 }
7682
7683 t.CreatedAt = string(sval)
7684 }
7685
7686 default:
7687 // Field doesn't exist on this type, so ignore it
7688 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7689 return err
7690 }
7691 }
7692 }
7693
7694 return nil
7695}
7696func (t *RepoPullComment) MarshalCBOR(w io.Writer) error {
7697 if t == nil {
7698 _, err := w.Write(cbg.CborNull)
7699 return err
7700 }
7701
7702 cw := cbg.NewCborWriter(w)
7703
7704 if _, err := cw.Write([]byte{164}); err != nil {
7705 return err
7706 }
7707
7708 // t.Body (string) (string)
7709 if len("body") > 1000000 {
7710 return xerrors.Errorf("Value in field \"body\" was too long")
7711 }
7712
7713 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
7714 return err
7715 }
7716 if _, err := cw.WriteString(string("body")); err != nil {
7717 return err
7718 }
7719
7720 if len(t.Body) > 1000000 {
7721 return xerrors.Errorf("Value in field t.Body was too long")
7722 }
7723
7724 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
7725 return err
7726 }
7727 if _, err := cw.WriteString(string(t.Body)); err != nil {
7728 return err
7729 }
7730
7731 // t.Pull (string) (string)
7732 if len("pull") > 1000000 {
7733 return xerrors.Errorf("Value in field \"pull\" was too long")
7734 }
7735
7736 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
7737 return err
7738 }
7739 if _, err := cw.WriteString(string("pull")); err != nil {
7740 return err
7741 }
7742
7743 if len(t.Pull) > 1000000 {
7744 return xerrors.Errorf("Value in field t.Pull was too long")
7745 }
7746
7747 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
7748 return err
7749 }
7750 if _, err := cw.WriteString(string(t.Pull)); err != nil {
7751 return err
7752 }
7753
7754 // t.LexiconTypeID (string) (string)
7755 if len("$type") > 1000000 {
7756 return xerrors.Errorf("Value in field \"$type\" was too long")
7757 }
7758
7759 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7760 return err
7761 }
7762 if _, err := cw.WriteString(string("$type")); err != nil {
7763 return err
7764 }
7765
7766 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.comment"))); err != nil {
7767 return err
7768 }
7769 if _, err := cw.WriteString(string("sh.tangled.repo.pull.comment")); err != nil {
7770 return err
7771 }
7772
7773 // t.CreatedAt (string) (string)
7774 if len("createdAt") > 1000000 {
7775 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7776 }
7777
7778 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7779 return err
7780 }
7781 if _, err := cw.WriteString(string("createdAt")); err != nil {
7782 return err
7783 }
7784
7785 if len(t.CreatedAt) > 1000000 {
7786 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7787 }
7788
7789 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7790 return err
7791 }
7792 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7793 return err
7794 }
7795 return nil
7796}
7797
7798func (t *RepoPullComment) UnmarshalCBOR(r io.Reader) (err error) {
7799 *t = RepoPullComment{}
7800
7801 cr := cbg.NewCborReader(r)
7802
7803 maj, extra, err := cr.ReadHeader()
7804 if err != nil {
7805 return err
7806 }
7807 defer func() {
7808 if err == io.EOF {
7809 err = io.ErrUnexpectedEOF
7810 }
7811 }()
7812
7813 if maj != cbg.MajMap {
7814 return fmt.Errorf("cbor input should be of type map")
7815 }
7816
7817 if extra > cbg.MaxLength {
7818 return fmt.Errorf("RepoPullComment: map struct too large (%d)", extra)
7819 }
7820
7821 n := extra
7822
7823 nameBuf := make([]byte, 9)
7824 for i := uint64(0); i < n; i++ {
7825 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7826 if err != nil {
7827 return err
7828 }
7829
7830 if !ok {
7831 // Field doesn't exist on this type, so ignore it
7832 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7833 return err
7834 }
7835 continue
7836 }
7837
7838 switch string(nameBuf[:nameLen]) {
7839 // t.Body (string) (string)
7840 case "body":
7841
7842 {
7843 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7844 if err != nil {
7845 return err
7846 }
7847
7848 t.Body = string(sval)
7849 }
7850 // t.Pull (string) (string)
7851 case "pull":
7852
7853 {
7854 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7855 if err != nil {
7856 return err
7857 }
7858
7859 t.Pull = string(sval)
7860 }
7861 // t.LexiconTypeID (string) (string)
7862 case "$type":
7863
7864 {
7865 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7866 if err != nil {
7867 return err
7868 }
7869
7870 t.LexiconTypeID = string(sval)
7871 }
7872 // t.CreatedAt (string) (string)
7873 case "createdAt":
7874
7875 {
7876 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7877 if err != nil {
7878 return err
7879 }
7880
7881 t.CreatedAt = string(sval)
7882 }
7883
7884 default:
7885 // Field doesn't exist on this type, so ignore it
7886 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7887 return err
7888 }
7889 }
7890 }
7891
7892 return nil
7893}
7894func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error {
7895 if t == nil {
7896 _, err := w.Write(cbg.CborNull)
7897 return err
7898 }
7899
7900 cw := cbg.NewCborWriter(w)
7901 fieldCount := 3
7902
7903 if t.Repo == nil {
7904 fieldCount--
7905 }
7906
7907 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7908 return err
7909 }
7910
7911 // t.Sha (string) (string)
7912 if len("sha") > 1000000 {
7913 return xerrors.Errorf("Value in field \"sha\" was too long")
7914 }
7915
7916 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sha"))); err != nil {
7917 return err
7918 }
7919 if _, err := cw.WriteString(string("sha")); err != nil {
7920 return err
7921 }
7922
7923 if len(t.Sha) > 1000000 {
7924 return xerrors.Errorf("Value in field t.Sha was too long")
7925 }
7926
7927 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Sha))); err != nil {
7928 return err
7929 }
7930 if _, err := cw.WriteString(string(t.Sha)); err != nil {
7931 return err
7932 }
7933
7934 // t.Repo (string) (string)
7935 if t.Repo != nil {
7936
7937 if len("repo") > 1000000 {
7938 return xerrors.Errorf("Value in field \"repo\" was too long")
7939 }
7940
7941 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
7942 return err
7943 }
7944 if _, err := cw.WriteString(string("repo")); err != nil {
7945 return err
7946 }
7947
7948 if t.Repo == nil {
7949 if _, err := cw.Write(cbg.CborNull); err != nil {
7950 return err
7951 }
7952 } else {
7953 if len(*t.Repo) > 1000000 {
7954 return xerrors.Errorf("Value in field t.Repo was too long")
7955 }
7956
7957 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
7958 return err
7959 }
7960 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
7961 return err
7962 }
7963 }
7964 }
7965
7966 // t.Branch (string) (string)
7967 if len("branch") > 1000000 {
7968 return xerrors.Errorf("Value in field \"branch\" was too long")
7969 }
7970
7971 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
7972 return err
7973 }
7974 if _, err := cw.WriteString(string("branch")); err != nil {
7975 return err
7976 }
7977
7978 if len(t.Branch) > 1000000 {
7979 return xerrors.Errorf("Value in field t.Branch was too long")
7980 }
7981
7982 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
7983 return err
7984 }
7985 if _, err := cw.WriteString(string(t.Branch)); err != nil {
7986 return err
7987 }
7988 return nil
7989}
7990
7991func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) {
7992 *t = RepoPull_Source{}
7993
7994 cr := cbg.NewCborReader(r)
7995
7996 maj, extra, err := cr.ReadHeader()
7997 if err != nil {
7998 return err
7999 }
8000 defer func() {
8001 if err == io.EOF {
8002 err = io.ErrUnexpectedEOF
8003 }
8004 }()
8005
8006 if maj != cbg.MajMap {
8007 return fmt.Errorf("cbor input should be of type map")
8008 }
8009
8010 if extra > cbg.MaxLength {
8011 return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra)
8012 }
8013
8014 n := extra
8015
8016 nameBuf := make([]byte, 6)
8017 for i := uint64(0); i < n; i++ {
8018 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8019 if err != nil {
8020 return err
8021 }
8022
8023 if !ok {
8024 // Field doesn't exist on this type, so ignore it
8025 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8026 return err
8027 }
8028 continue
8029 }
8030
8031 switch string(nameBuf[:nameLen]) {
8032 // t.Sha (string) (string)
8033 case "sha":
8034
8035 {
8036 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8037 if err != nil {
8038 return err
8039 }
8040
8041 t.Sha = string(sval)
8042 }
8043 // t.Repo (string) (string)
8044 case "repo":
8045
8046 {
8047 b, err := cr.ReadByte()
8048 if err != nil {
8049 return err
8050 }
8051 if b != cbg.CborNull[0] {
8052 if err := cr.UnreadByte(); err != nil {
8053 return err
8054 }
8055
8056 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8057 if err != nil {
8058 return err
8059 }
8060
8061 t.Repo = (*string)(&sval)
8062 }
8063 }
8064 // t.Branch (string) (string)
8065 case "branch":
8066
8067 {
8068 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8069 if err != nil {
8070 return err
8071 }
8072
8073 t.Branch = string(sval)
8074 }
8075
8076 default:
8077 // Field doesn't exist on this type, so ignore it
8078 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8079 return err
8080 }
8081 }
8082 }
8083
8084 return nil
8085}
8086func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error {
8087 if t == nil {
8088 _, err := w.Write(cbg.CborNull)
8089 return err
8090 }
8091
8092 cw := cbg.NewCborWriter(w)
8093
8094 if _, err := cw.Write([]byte{163}); err != nil {
8095 return err
8096 }
8097
8098 // t.Pull (string) (string)
8099 if len("pull") > 1000000 {
8100 return xerrors.Errorf("Value in field \"pull\" was too long")
8101 }
8102
8103 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
8104 return err
8105 }
8106 if _, err := cw.WriteString(string("pull")); err != nil {
8107 return err
8108 }
8109
8110 if len(t.Pull) > 1000000 {
8111 return xerrors.Errorf("Value in field t.Pull was too long")
8112 }
8113
8114 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
8115 return err
8116 }
8117 if _, err := cw.WriteString(string(t.Pull)); err != nil {
8118 return err
8119 }
8120
8121 // t.LexiconTypeID (string) (string)
8122 if len("$type") > 1000000 {
8123 return xerrors.Errorf("Value in field \"$type\" was too long")
8124 }
8125
8126 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8127 return err
8128 }
8129 if _, err := cw.WriteString(string("$type")); err != nil {
8130 return err
8131 }
8132
8133 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil {
8134 return err
8135 }
8136 if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil {
8137 return err
8138 }
8139
8140 // t.Status (string) (string)
8141 if len("status") > 1000000 {
8142 return xerrors.Errorf("Value in field \"status\" was too long")
8143 }
8144
8145 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
8146 return err
8147 }
8148 if _, err := cw.WriteString(string("status")); err != nil {
8149 return err
8150 }
8151
8152 if len(t.Status) > 1000000 {
8153 return xerrors.Errorf("Value in field t.Status was too long")
8154 }
8155
8156 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
8157 return err
8158 }
8159 if _, err := cw.WriteString(string(t.Status)); err != nil {
8160 return err
8161 }
8162 return nil
8163}
8164
8165func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) {
8166 *t = RepoPullStatus{}
8167
8168 cr := cbg.NewCborReader(r)
8169
8170 maj, extra, err := cr.ReadHeader()
8171 if err != nil {
8172 return err
8173 }
8174 defer func() {
8175 if err == io.EOF {
8176 err = io.ErrUnexpectedEOF
8177 }
8178 }()
8179
8180 if maj != cbg.MajMap {
8181 return fmt.Errorf("cbor input should be of type map")
8182 }
8183
8184 if extra > cbg.MaxLength {
8185 return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra)
8186 }
8187
8188 n := extra
8189
8190 nameBuf := make([]byte, 6)
8191 for i := uint64(0); i < n; i++ {
8192 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8193 if err != nil {
8194 return err
8195 }
8196
8197 if !ok {
8198 // Field doesn't exist on this type, so ignore it
8199 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8200 return err
8201 }
8202 continue
8203 }
8204
8205 switch string(nameBuf[:nameLen]) {
8206 // t.Pull (string) (string)
8207 case "pull":
8208
8209 {
8210 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8211 if err != nil {
8212 return err
8213 }
8214
8215 t.Pull = string(sval)
8216 }
8217 // t.LexiconTypeID (string) (string)
8218 case "$type":
8219
8220 {
8221 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8222 if err != nil {
8223 return err
8224 }
8225
8226 t.LexiconTypeID = string(sval)
8227 }
8228 // t.Status (string) (string)
8229 case "status":
8230
8231 {
8232 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8233 if err != nil {
8234 return err
8235 }
8236
8237 t.Status = string(sval)
8238 }
8239
8240 default:
8241 // Field doesn't exist on this type, so ignore it
8242 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8243 return err
8244 }
8245 }
8246 }
8247
8248 return nil
8249}
8250func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error {
8251 if t == nil {
8252 _, err := w.Write(cbg.CborNull)
8253 return err
8254 }
8255
8256 cw := cbg.NewCborWriter(w)
8257
8258 if _, err := cw.Write([]byte{162}); err != nil {
8259 return err
8260 }
8261
8262 // t.Repo (string) (string)
8263 if len("repo") > 1000000 {
8264 return xerrors.Errorf("Value in field \"repo\" was too long")
8265 }
8266
8267 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
8268 return err
8269 }
8270 if _, err := cw.WriteString(string("repo")); err != nil {
8271 return err
8272 }
8273
8274 if len(t.Repo) > 1000000 {
8275 return xerrors.Errorf("Value in field t.Repo was too long")
8276 }
8277
8278 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
8279 return err
8280 }
8281 if _, err := cw.WriteString(string(t.Repo)); err != nil {
8282 return err
8283 }
8284
8285 // t.Branch (string) (string)
8286 if len("branch") > 1000000 {
8287 return xerrors.Errorf("Value in field \"branch\" was too long")
8288 }
8289
8290 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
8291 return err
8292 }
8293 if _, err := cw.WriteString(string("branch")); err != nil {
8294 return err
8295 }
8296
8297 if len(t.Branch) > 1000000 {
8298 return xerrors.Errorf("Value in field t.Branch was too long")
8299 }
8300
8301 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
8302 return err
8303 }
8304 if _, err := cw.WriteString(string(t.Branch)); err != nil {
8305 return err
8306 }
8307 return nil
8308}
8309
8310func (t *RepoPull_Target) UnmarshalCBOR(r io.Reader) (err error) {
8311 *t = RepoPull_Target{}
8312
8313 cr := cbg.NewCborReader(r)
8314
8315 maj, extra, err := cr.ReadHeader()
8316 if err != nil {
8317 return err
8318 }
8319 defer func() {
8320 if err == io.EOF {
8321 err = io.ErrUnexpectedEOF
8322 }
8323 }()
8324
8325 if maj != cbg.MajMap {
8326 return fmt.Errorf("cbor input should be of type map")
8327 }
8328
8329 if extra > cbg.MaxLength {
8330 return fmt.Errorf("RepoPull_Target: map struct too large (%d)", extra)
8331 }
8332
8333 n := extra
8334
8335 nameBuf := make([]byte, 6)
8336 for i := uint64(0); i < n; i++ {
8337 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8338 if err != nil {
8339 return err
8340 }
8341
8342 if !ok {
8343 // Field doesn't exist on this type, so ignore it
8344 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8345 return err
8346 }
8347 continue
8348 }
8349
8350 switch string(nameBuf[:nameLen]) {
8351 // t.Repo (string) (string)
8352 case "repo":
8353
8354 {
8355 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8356 if err != nil {
8357 return err
8358 }
8359
8360 t.Repo = string(sval)
8361 }
8362 // t.Branch (string) (string)
8363 case "branch":
8364
8365 {
8366 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8367 if err != nil {
8368 return err
8369 }
8370
8371 t.Branch = string(sval)
8372 }
8373
8374 default:
8375 // Field doesn't exist on this type, so ignore it
8376 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8377 return err
8378 }
8379 }
8380 }
8381
8382 return nil
8383}
8384func (t *Spindle) MarshalCBOR(w io.Writer) error {
8385 if t == nil {
8386 _, err := w.Write(cbg.CborNull)
8387 return err
8388 }
8389
8390 cw := cbg.NewCborWriter(w)
8391
8392 if _, err := cw.Write([]byte{162}); err != nil {
8393 return err
8394 }
8395
8396 // t.LexiconTypeID (string) (string)
8397 if len("$type") > 1000000 {
8398 return xerrors.Errorf("Value in field \"$type\" was too long")
8399 }
8400
8401 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8402 return err
8403 }
8404 if _, err := cw.WriteString(string("$type")); err != nil {
8405 return err
8406 }
8407
8408 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle"))); err != nil {
8409 return err
8410 }
8411 if _, err := cw.WriteString(string("sh.tangled.spindle")); err != nil {
8412 return err
8413 }
8414
8415 // t.CreatedAt (string) (string)
8416 if len("createdAt") > 1000000 {
8417 return xerrors.Errorf("Value in field \"createdAt\" was too long")
8418 }
8419
8420 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
8421 return err
8422 }
8423 if _, err := cw.WriteString(string("createdAt")); err != nil {
8424 return err
8425 }
8426
8427 if len(t.CreatedAt) > 1000000 {
8428 return xerrors.Errorf("Value in field t.CreatedAt was too long")
8429 }
8430
8431 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
8432 return err
8433 }
8434 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
8435 return err
8436 }
8437 return nil
8438}
8439
8440func (t *Spindle) UnmarshalCBOR(r io.Reader) (err error) {
8441 *t = Spindle{}
8442
8443 cr := cbg.NewCborReader(r)
8444
8445 maj, extra, err := cr.ReadHeader()
8446 if err != nil {
8447 return err
8448 }
8449 defer func() {
8450 if err == io.EOF {
8451 err = io.ErrUnexpectedEOF
8452 }
8453 }()
8454
8455 if maj != cbg.MajMap {
8456 return fmt.Errorf("cbor input should be of type map")
8457 }
8458
8459 if extra > cbg.MaxLength {
8460 return fmt.Errorf("Spindle: map struct too large (%d)", extra)
8461 }
8462
8463 n := extra
8464
8465 nameBuf := make([]byte, 9)
8466 for i := uint64(0); i < n; i++ {
8467 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8468 if err != nil {
8469 return err
8470 }
8471
8472 if !ok {
8473 // Field doesn't exist on this type, so ignore it
8474 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8475 return err
8476 }
8477 continue
8478 }
8479
8480 switch string(nameBuf[:nameLen]) {
8481 // t.LexiconTypeID (string) (string)
8482 case "$type":
8483
8484 {
8485 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8486 if err != nil {
8487 return err
8488 }
8489
8490 t.LexiconTypeID = string(sval)
8491 }
8492 // t.CreatedAt (string) (string)
8493 case "createdAt":
8494
8495 {
8496 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8497 if err != nil {
8498 return err
8499 }
8500
8501 t.CreatedAt = string(sval)
8502 }
8503
8504 default:
8505 // Field doesn't exist on this type, so ignore it
8506 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8507 return err
8508 }
8509 }
8510 }
8511
8512 return nil
8513}
8514func (t *SpindleMember) MarshalCBOR(w io.Writer) error {
8515 if t == nil {
8516 _, err := w.Write(cbg.CborNull)
8517 return err
8518 }
8519
8520 cw := cbg.NewCborWriter(w)
8521
8522 if _, err := cw.Write([]byte{164}); err != nil {
8523 return err
8524 }
8525
8526 // t.LexiconTypeID (string) (string)
8527 if len("$type") > 1000000 {
8528 return xerrors.Errorf("Value in field \"$type\" was too long")
8529 }
8530
8531 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8532 return err
8533 }
8534 if _, err := cw.WriteString(string("$type")); err != nil {
8535 return err
8536 }
8537
8538 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle.member"))); err != nil {
8539 return err
8540 }
8541 if _, err := cw.WriteString(string("sh.tangled.spindle.member")); err != nil {
8542 return err
8543 }
8544
8545 // t.Subject (string) (string)
8546 if len("subject") > 1000000 {
8547 return xerrors.Errorf("Value in field \"subject\" was too long")
8548 }
8549
8550 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
8551 return err
8552 }
8553 if _, err := cw.WriteString(string("subject")); err != nil {
8554 return err
8555 }
8556
8557 if len(t.Subject) > 1000000 {
8558 return xerrors.Errorf("Value in field t.Subject was too long")
8559 }
8560
8561 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
8562 return err
8563 }
8564 if _, err := cw.WriteString(string(t.Subject)); err != nil {
8565 return err
8566 }
8567
8568 // t.Instance (string) (string)
8569 if len("instance") > 1000000 {
8570 return xerrors.Errorf("Value in field \"instance\" was too long")
8571 }
8572
8573 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("instance"))); err != nil {
8574 return err
8575 }
8576 if _, err := cw.WriteString(string("instance")); err != nil {
8577 return err
8578 }
8579
8580 if len(t.Instance) > 1000000 {
8581 return xerrors.Errorf("Value in field t.Instance was too long")
8582 }
8583
8584 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Instance))); err != nil {
8585 return err
8586 }
8587 if _, err := cw.WriteString(string(t.Instance)); err != nil {
8588 return err
8589 }
8590
8591 // t.CreatedAt (string) (string)
8592 if len("createdAt") > 1000000 {
8593 return xerrors.Errorf("Value in field \"createdAt\" was too long")
8594 }
8595
8596 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
8597 return err
8598 }
8599 if _, err := cw.WriteString(string("createdAt")); err != nil {
8600 return err
8601 }
8602
8603 if len(t.CreatedAt) > 1000000 {
8604 return xerrors.Errorf("Value in field t.CreatedAt was too long")
8605 }
8606
8607 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
8608 return err
8609 }
8610 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
8611 return err
8612 }
8613 return nil
8614}
8615
8616func (t *SpindleMember) UnmarshalCBOR(r io.Reader) (err error) {
8617 *t = SpindleMember{}
8618
8619 cr := cbg.NewCborReader(r)
8620
8621 maj, extra, err := cr.ReadHeader()
8622 if err != nil {
8623 return err
8624 }
8625 defer func() {
8626 if err == io.EOF {
8627 err = io.ErrUnexpectedEOF
8628 }
8629 }()
8630
8631 if maj != cbg.MajMap {
8632 return fmt.Errorf("cbor input should be of type map")
8633 }
8634
8635 if extra > cbg.MaxLength {
8636 return fmt.Errorf("SpindleMember: map struct too large (%d)", extra)
8637 }
8638
8639 n := extra
8640
8641 nameBuf := make([]byte, 9)
8642 for i := uint64(0); i < n; i++ {
8643 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8644 if err != nil {
8645 return err
8646 }
8647
8648 if !ok {
8649 // Field doesn't exist on this type, so ignore it
8650 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8651 return err
8652 }
8653 continue
8654 }
8655
8656 switch string(nameBuf[:nameLen]) {
8657 // t.LexiconTypeID (string) (string)
8658 case "$type":
8659
8660 {
8661 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8662 if err != nil {
8663 return err
8664 }
8665
8666 t.LexiconTypeID = string(sval)
8667 }
8668 // t.Subject (string) (string)
8669 case "subject":
8670
8671 {
8672 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8673 if err != nil {
8674 return err
8675 }
8676
8677 t.Subject = string(sval)
8678 }
8679 // t.Instance (string) (string)
8680 case "instance":
8681
8682 {
8683 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8684 if err != nil {
8685 return err
8686 }
8687
8688 t.Instance = string(sval)
8689 }
8690 // t.CreatedAt (string) (string)
8691 case "createdAt":
8692
8693 {
8694 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8695 if err != nil {
8696 return err
8697 }
8698
8699 t.CreatedAt = string(sval)
8700 }
8701
8702 default:
8703 // Field doesn't exist on this type, so ignore it
8704 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8705 return err
8706 }
8707 }
8708 }
8709
8710 return nil
8711}
8712func (t *String) MarshalCBOR(w io.Writer) error {
8713 if t == nil {
8714 _, err := w.Write(cbg.CborNull)
8715 return err
8716 }
8717
8718 cw := cbg.NewCborWriter(w)
8719
8720 if _, err := cw.Write([]byte{165}); err != nil {
8721 return err
8722 }
8723
8724 // t.LexiconTypeID (string) (string)
8725 if len("$type") > 1000000 {
8726 return xerrors.Errorf("Value in field \"$type\" was too long")
8727 }
8728
8729 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8730 return err
8731 }
8732 if _, err := cw.WriteString(string("$type")); err != nil {
8733 return err
8734 }
8735
8736 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.string"))); err != nil {
8737 return err
8738 }
8739 if _, err := cw.WriteString(string("sh.tangled.string")); err != nil {
8740 return err
8741 }
8742
8743 // t.Contents (string) (string)
8744 if len("contents") > 1000000 {
8745 return xerrors.Errorf("Value in field \"contents\" was too long")
8746 }
8747
8748 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("contents"))); err != nil {
8749 return err
8750 }
8751 if _, err := cw.WriteString(string("contents")); err != nil {
8752 return err
8753 }
8754
8755 if len(t.Contents) > 1000000 {
8756 return xerrors.Errorf("Value in field t.Contents was too long")
8757 }
8758
8759 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Contents))); err != nil {
8760 return err
8761 }
8762 if _, err := cw.WriteString(string(t.Contents)); err != nil {
8763 return err
8764 }
8765
8766 // t.Filename (string) (string)
8767 if len("filename") > 1000000 {
8768 return xerrors.Errorf("Value in field \"filename\" was too long")
8769 }
8770
8771 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("filename"))); err != nil {
8772 return err
8773 }
8774 if _, err := cw.WriteString(string("filename")); err != nil {
8775 return err
8776 }
8777
8778 if len(t.Filename) > 1000000 {
8779 return xerrors.Errorf("Value in field t.Filename was too long")
8780 }
8781
8782 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Filename))); err != nil {
8783 return err
8784 }
8785 if _, err := cw.WriteString(string(t.Filename)); err != nil {
8786 return err
8787 }
8788
8789 // t.CreatedAt (string) (string)
8790 if len("createdAt") > 1000000 {
8791 return xerrors.Errorf("Value in field \"createdAt\" was too long")
8792 }
8793
8794 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
8795 return err
8796 }
8797 if _, err := cw.WriteString(string("createdAt")); err != nil {
8798 return err
8799 }
8800
8801 if len(t.CreatedAt) > 1000000 {
8802 return xerrors.Errorf("Value in field t.CreatedAt was too long")
8803 }
8804
8805 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
8806 return err
8807 }
8808 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
8809 return err
8810 }
8811
8812 // t.Description (string) (string)
8813 if len("description") > 1000000 {
8814 return xerrors.Errorf("Value in field \"description\" was too long")
8815 }
8816
8817 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
8818 return err
8819 }
8820 if _, err := cw.WriteString(string("description")); err != nil {
8821 return err
8822 }
8823
8824 if len(t.Description) > 1000000 {
8825 return xerrors.Errorf("Value in field t.Description was too long")
8826 }
8827
8828 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil {
8829 return err
8830 }
8831 if _, err := cw.WriteString(string(t.Description)); err != nil {
8832 return err
8833 }
8834 return nil
8835}
8836
8837func (t *String) UnmarshalCBOR(r io.Reader) (err error) {
8838 *t = String{}
8839
8840 cr := cbg.NewCborReader(r)
8841
8842 maj, extra, err := cr.ReadHeader()
8843 if err != nil {
8844 return err
8845 }
8846 defer func() {
8847 if err == io.EOF {
8848 err = io.ErrUnexpectedEOF
8849 }
8850 }()
8851
8852 if maj != cbg.MajMap {
8853 return fmt.Errorf("cbor input should be of type map")
8854 }
8855
8856 if extra > cbg.MaxLength {
8857 return fmt.Errorf("String: map struct too large (%d)", extra)
8858 }
8859
8860 n := extra
8861
8862 nameBuf := make([]byte, 11)
8863 for i := uint64(0); i < n; i++ {
8864 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8865 if err != nil {
8866 return err
8867 }
8868
8869 if !ok {
8870 // Field doesn't exist on this type, so ignore it
8871 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8872 return err
8873 }
8874 continue
8875 }
8876
8877 switch string(nameBuf[:nameLen]) {
8878 // t.LexiconTypeID (string) (string)
8879 case "$type":
8880
8881 {
8882 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8883 if err != nil {
8884 return err
8885 }
8886
8887 t.LexiconTypeID = string(sval)
8888 }
8889 // t.Contents (string) (string)
8890 case "contents":
8891
8892 {
8893 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8894 if err != nil {
8895 return err
8896 }
8897
8898 t.Contents = string(sval)
8899 }
8900 // t.Filename (string) (string)
8901 case "filename":
8902
8903 {
8904 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8905 if err != nil {
8906 return err
8907 }
8908
8909 t.Filename = string(sval)
8910 }
8911 // t.CreatedAt (string) (string)
8912 case "createdAt":
8913
8914 {
8915 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8916 if err != nil {
8917 return err
8918 }
8919
8920 t.CreatedAt = string(sval)
8921 }
8922 // t.Description (string) (string)
8923 case "description":
8924
8925 {
8926 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8927 if err != nil {
8928 return err
8929 }
8930
8931 t.Description = string(sval)
8932 }
8933
8934 default:
8935 // Field doesn't exist on this type, so ignore it
8936 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8937 return err
8938 }
8939 }
8940 }
8941
8942 return nil
8943}