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