dzming.li
A vibe coded tangled fork which supports pijul.
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 *PijulRefUpdate) 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 fieldCount := 7
3636
3637 if t.Languages == nil {
3638 fieldCount--
3639 }
3640
3641 if t.OldState == nil {
3642 fieldCount--
3643 }
3644
3645 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3646 return err
3647 }
3648
3649 // t.Repo (string) (string)
3650 if len("repo") > 1000000 {
3651 return xerrors.Errorf("Value in field \"repo\" was too long")
3652 }
3653
3654 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
3655 return err
3656 }
3657 if _, err := cw.WriteString(string("repo")); err != nil {
3658 return err
3659 }
3660
3661 if len(t.Repo) > 1000000 {
3662 return xerrors.Errorf("Value in field t.Repo was too long")
3663 }
3664
3665 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
3666 return err
3667 }
3668 if _, err := cw.WriteString(string(t.Repo)); err != nil {
3669 return err
3670 }
3671
3672 // t.LexiconTypeID (string) (string)
3673 if len("$type") > 1000000 {
3674 return xerrors.Errorf("Value in field \"$type\" was too long")
3675 }
3676
3677 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3678 return err
3679 }
3680 if _, err := cw.WriteString(string("$type")); err != nil {
3681 return err
3682 }
3683
3684 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pijul.refUpdate"))); err != nil {
3685 return err
3686 }
3687 if _, err := cw.WriteString(string("sh.tangled.pijul.refUpdate")); err != nil {
3688 return err
3689 }
3690
3691 // t.Changes ([]string) (slice)
3692 if len("changes") > 1000000 {
3693 return xerrors.Errorf("Value in field \"changes\" was too long")
3694 }
3695
3696 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("changes"))); err != nil {
3697 return err
3698 }
3699 if _, err := cw.WriteString(string("changes")); err != nil {
3700 return err
3701 }
3702
3703 if len(t.Changes) > 8192 {
3704 return xerrors.Errorf("Slice value in field t.Changes was too long")
3705 }
3706
3707 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Changes))); err != nil {
3708 return err
3709 }
3710 for _, v := range t.Changes {
3711 if len(v) > 1000000 {
3712 return xerrors.Errorf("Value in field v was too long")
3713 }
3714
3715 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
3716 return err
3717 }
3718 if _, err := cw.WriteString(string(v)); err != nil {
3719 return err
3720 }
3721
3722 }
3723
3724 // t.Channel (string) (string)
3725 if len("channel") > 1000000 {
3726 return xerrors.Errorf("Value in field \"channel\" was too long")
3727 }
3728
3729 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("channel"))); err != nil {
3730 return err
3731 }
3732 if _, err := cw.WriteString(string("channel")); err != nil {
3733 return err
3734 }
3735
3736 if len(t.Channel) > 1000000 {
3737 return xerrors.Errorf("Value in field t.Channel was too long")
3738 }
3739
3740 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Channel))); err != nil {
3741 return err
3742 }
3743 if _, err := cw.WriteString(string(t.Channel)); err != nil {
3744 return err
3745 }
3746
3747 // t.NewState (string) (string)
3748 if len("newState") > 1000000 {
3749 return xerrors.Errorf("Value in field \"newState\" was too long")
3750 }
3751
3752 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newState"))); err != nil {
3753 return err
3754 }
3755 if _, err := cw.WriteString(string("newState")); err != nil {
3756 return err
3757 }
3758
3759 if len(t.NewState) > 1000000 {
3760 return xerrors.Errorf("Value in field t.NewState was too long")
3761 }
3762
3763 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewState))); err != nil {
3764 return err
3765 }
3766 if _, err := cw.WriteString(string(t.NewState)); err != nil {
3767 return err
3768 }
3769
3770 // t.OldState (string) (string)
3771 if t.OldState != nil {
3772
3773 if len("oldState") > 1000000 {
3774 return xerrors.Errorf("Value in field \"oldState\" was too long")
3775 }
3776
3777 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldState"))); err != nil {
3778 return err
3779 }
3780 if _, err := cw.WriteString(string("oldState")); err != nil {
3781 return err
3782 }
3783
3784 if t.OldState == nil {
3785 if _, err := cw.Write(cbg.CborNull); err != nil {
3786 return err
3787 }
3788 } else {
3789 if len(*t.OldState) > 1000000 {
3790 return xerrors.Errorf("Value in field t.OldState was too long")
3791 }
3792
3793 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.OldState))); err != nil {
3794 return err
3795 }
3796 if _, err := cw.WriteString(string(*t.OldState)); err != nil {
3797 return err
3798 }
3799 }
3800 }
3801
3802 // t.Languages (tangled.PijulRefUpdate_Languages) (struct)
3803 if t.Languages != nil {
3804
3805 if len("languages") > 1000000 {
3806 return xerrors.Errorf("Value in field \"languages\" was too long")
3807 }
3808
3809 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("languages"))); err != nil {
3810 return err
3811 }
3812 if _, err := cw.WriteString(string("languages")); err != nil {
3813 return err
3814 }
3815
3816 if err := t.Languages.MarshalCBOR(cw); err != nil {
3817 return err
3818 }
3819 }
3820 return nil
3821}
3822
3823func (t *PijulRefUpdate) UnmarshalCBOR(r io.Reader) (err error) {
3824 *t = PijulRefUpdate{}
3825
3826 cr := cbg.NewCborReader(r)
3827
3828 maj, extra, err := cr.ReadHeader()
3829 if err != nil {
3830 return err
3831 }
3832 defer func() {
3833 if err == io.EOF {
3834 err = io.ErrUnexpectedEOF
3835 }
3836 }()
3837
3838 if maj != cbg.MajMap {
3839 return fmt.Errorf("cbor input should be of type map")
3840 }
3841
3842 if extra > cbg.MaxLength {
3843 return fmt.Errorf("PijulRefUpdate: map struct too large (%d)", extra)
3844 }
3845
3846 n := extra
3847
3848 nameBuf := make([]byte, 9)
3849 for i := uint64(0); i < n; i++ {
3850 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3851 if err != nil {
3852 return err
3853 }
3854
3855 if !ok {
3856 // Field doesn't exist on this type, so ignore it
3857 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3858 return err
3859 }
3860 continue
3861 }
3862
3863 switch string(nameBuf[:nameLen]) {
3864 // t.Repo (string) (string)
3865 case "repo":
3866
3867 {
3868 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3869 if err != nil {
3870 return err
3871 }
3872
3873 t.Repo = string(sval)
3874 }
3875 // t.LexiconTypeID (string) (string)
3876 case "$type":
3877
3878 {
3879 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3880 if err != nil {
3881 return err
3882 }
3883
3884 t.LexiconTypeID = string(sval)
3885 }
3886 // t.Changes ([]string) (slice)
3887 case "changes":
3888
3889 maj, extra, err = cr.ReadHeader()
3890 if err != nil {
3891 return err
3892 }
3893
3894 if extra > 8192 {
3895 return fmt.Errorf("t.Changes: array too large (%d)", extra)
3896 }
3897
3898 if maj != cbg.MajArray {
3899 return fmt.Errorf("expected cbor array")
3900 }
3901
3902 if extra > 0 {
3903 t.Changes = make([]string, extra)
3904 }
3905
3906 for i := 0; i < int(extra); i++ {
3907 {
3908 var maj byte
3909 var extra uint64
3910 var err error
3911 _ = maj
3912 _ = extra
3913 _ = err
3914
3915 {
3916 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3917 if err != nil {
3918 return err
3919 }
3920
3921 t.Changes[i] = string(sval)
3922 }
3923
3924 }
3925 }
3926 // t.Channel (string) (string)
3927 case "channel":
3928
3929 {
3930 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3931 if err != nil {
3932 return err
3933 }
3934
3935 t.Channel = string(sval)
3936 }
3937 // t.NewState (string) (string)
3938 case "newState":
3939
3940 {
3941 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3942 if err != nil {
3943 return err
3944 }
3945
3946 t.NewState = string(sval)
3947 }
3948 // t.OldState (string) (string)
3949 case "oldState":
3950
3951 {
3952 b, err := cr.ReadByte()
3953 if err != nil {
3954 return err
3955 }
3956 if b != cbg.CborNull[0] {
3957 if err := cr.UnreadByte(); err != nil {
3958 return err
3959 }
3960
3961 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3962 if err != nil {
3963 return err
3964 }
3965
3966 t.OldState = (*string)(&sval)
3967 }
3968 }
3969 // t.Languages (tangled.PijulRefUpdate_Languages) (struct)
3970 case "languages":
3971
3972 {
3973
3974 b, err := cr.ReadByte()
3975 if err != nil {
3976 return err
3977 }
3978 if b != cbg.CborNull[0] {
3979 if err := cr.UnreadByte(); err != nil {
3980 return err
3981 }
3982 t.Languages = new(PijulRefUpdate_Languages)
3983 if err := t.Languages.UnmarshalCBOR(cr); err != nil {
3984 return xerrors.Errorf("unmarshaling t.Languages pointer: %w", err)
3985 }
3986 }
3987
3988 }
3989
3990 default:
3991 // Field doesn't exist on this type, so ignore it
3992 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3993 return err
3994 }
3995 }
3996 }
3997
3998 return nil
3999}
4000func (t *Pipeline) MarshalCBOR(w io.Writer) error {
4001 if t == nil {
4002 _, err := w.Write(cbg.CborNull)
4003 return err
4004 }
4005
4006 cw := cbg.NewCborWriter(w)
4007
4008 if _, err := cw.Write([]byte{163}); err != nil {
4009 return err
4010 }
4011
4012 // t.LexiconTypeID (string) (string)
4013 if len("$type") > 1000000 {
4014 return xerrors.Errorf("Value in field \"$type\" was too long")
4015 }
4016
4017 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
4018 return err
4019 }
4020 if _, err := cw.WriteString(string("$type")); err != nil {
4021 return err
4022 }
4023
4024 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil {
4025 return err
4026 }
4027 if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil {
4028 return err
4029 }
4030
4031 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
4032 if len("workflows") > 1000000 {
4033 return xerrors.Errorf("Value in field \"workflows\" was too long")
4034 }
4035
4036 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil {
4037 return err
4038 }
4039 if _, err := cw.WriteString(string("workflows")); err != nil {
4040 return err
4041 }
4042
4043 if len(t.Workflows) > 8192 {
4044 return xerrors.Errorf("Slice value in field t.Workflows was too long")
4045 }
4046
4047 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil {
4048 return err
4049 }
4050 for _, v := range t.Workflows {
4051 if err := v.MarshalCBOR(cw); err != nil {
4052 return err
4053 }
4054
4055 }
4056
4057 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
4058 if len("triggerMetadata") > 1000000 {
4059 return xerrors.Errorf("Value in field \"triggerMetadata\" was too long")
4060 }
4061
4062 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil {
4063 return err
4064 }
4065 if _, err := cw.WriteString(string("triggerMetadata")); err != nil {
4066 return err
4067 }
4068
4069 if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil {
4070 return err
4071 }
4072 return nil
4073}
4074
4075func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) {
4076 *t = Pipeline{}
4077
4078 cr := cbg.NewCborReader(r)
4079
4080 maj, extra, err := cr.ReadHeader()
4081 if err != nil {
4082 return err
4083 }
4084 defer func() {
4085 if err == io.EOF {
4086 err = io.ErrUnexpectedEOF
4087 }
4088 }()
4089
4090 if maj != cbg.MajMap {
4091 return fmt.Errorf("cbor input should be of type map")
4092 }
4093
4094 if extra > cbg.MaxLength {
4095 return fmt.Errorf("Pipeline: map struct too large (%d)", extra)
4096 }
4097
4098 n := extra
4099
4100 nameBuf := make([]byte, 15)
4101 for i := uint64(0); i < n; i++ {
4102 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4103 if err != nil {
4104 return err
4105 }
4106
4107 if !ok {
4108 // Field doesn't exist on this type, so ignore it
4109 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4110 return err
4111 }
4112 continue
4113 }
4114
4115 switch string(nameBuf[:nameLen]) {
4116 // t.LexiconTypeID (string) (string)
4117 case "$type":
4118
4119 {
4120 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4121 if err != nil {
4122 return err
4123 }
4124
4125 t.LexiconTypeID = string(sval)
4126 }
4127 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
4128 case "workflows":
4129
4130 maj, extra, err = cr.ReadHeader()
4131 if err != nil {
4132 return err
4133 }
4134
4135 if extra > 8192 {
4136 return fmt.Errorf("t.Workflows: array too large (%d)", extra)
4137 }
4138
4139 if maj != cbg.MajArray {
4140 return fmt.Errorf("expected cbor array")
4141 }
4142
4143 if extra > 0 {
4144 t.Workflows = make([]*Pipeline_Workflow, extra)
4145 }
4146
4147 for i := 0; i < int(extra); i++ {
4148 {
4149 var maj byte
4150 var extra uint64
4151 var err error
4152 _ = maj
4153 _ = extra
4154 _ = err
4155
4156 {
4157
4158 b, err := cr.ReadByte()
4159 if err != nil {
4160 return err
4161 }
4162 if b != cbg.CborNull[0] {
4163 if err := cr.UnreadByte(); err != nil {
4164 return err
4165 }
4166 t.Workflows[i] = new(Pipeline_Workflow)
4167 if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil {
4168 return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err)
4169 }
4170 }
4171
4172 }
4173
4174 }
4175 }
4176 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
4177 case "triggerMetadata":
4178
4179 {
4180
4181 b, err := cr.ReadByte()
4182 if err != nil {
4183 return err
4184 }
4185 if b != cbg.CborNull[0] {
4186 if err := cr.UnreadByte(); err != nil {
4187 return err
4188 }
4189 t.TriggerMetadata = new(Pipeline_TriggerMetadata)
4190 if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil {
4191 return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err)
4192 }
4193 }
4194
4195 }
4196
4197 default:
4198 // Field doesn't exist on this type, so ignore it
4199 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4200 return err
4201 }
4202 }
4203 }
4204
4205 return nil
4206}
4207func (t *Pipeline_CloneOpts) MarshalCBOR(w io.Writer) error {
4208 if t == nil {
4209 _, err := w.Write(cbg.CborNull)
4210 return err
4211 }
4212
4213 cw := cbg.NewCborWriter(w)
4214
4215 if _, err := cw.Write([]byte{163}); err != nil {
4216 return err
4217 }
4218
4219 // t.Skip (bool) (bool)
4220 if len("skip") > 1000000 {
4221 return xerrors.Errorf("Value in field \"skip\" was too long")
4222 }
4223
4224 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("skip"))); err != nil {
4225 return err
4226 }
4227 if _, err := cw.WriteString(string("skip")); err != nil {
4228 return err
4229 }
4230
4231 if err := cbg.WriteBool(w, t.Skip); err != nil {
4232 return err
4233 }
4234
4235 // t.Depth (int64) (int64)
4236 if len("depth") > 1000000 {
4237 return xerrors.Errorf("Value in field \"depth\" was too long")
4238 }
4239
4240 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("depth"))); err != nil {
4241 return err
4242 }
4243 if _, err := cw.WriteString(string("depth")); err != nil {
4244 return err
4245 }
4246
4247 if t.Depth >= 0 {
4248 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Depth)); err != nil {
4249 return err
4250 }
4251 } else {
4252 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Depth-1)); err != nil {
4253 return err
4254 }
4255 }
4256
4257 // t.Submodules (bool) (bool)
4258 if len("submodules") > 1000000 {
4259 return xerrors.Errorf("Value in field \"submodules\" was too long")
4260 }
4261
4262 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("submodules"))); err != nil {
4263 return err
4264 }
4265 if _, err := cw.WriteString(string("submodules")); err != nil {
4266 return err
4267 }
4268
4269 if err := cbg.WriteBool(w, t.Submodules); err != nil {
4270 return err
4271 }
4272 return nil
4273}
4274
4275func (t *Pipeline_CloneOpts) UnmarshalCBOR(r io.Reader) (err error) {
4276 *t = Pipeline_CloneOpts{}
4277
4278 cr := cbg.NewCborReader(r)
4279
4280 maj, extra, err := cr.ReadHeader()
4281 if err != nil {
4282 return err
4283 }
4284 defer func() {
4285 if err == io.EOF {
4286 err = io.ErrUnexpectedEOF
4287 }
4288 }()
4289
4290 if maj != cbg.MajMap {
4291 return fmt.Errorf("cbor input should be of type map")
4292 }
4293
4294 if extra > cbg.MaxLength {
4295 return fmt.Errorf("Pipeline_CloneOpts: map struct too large (%d)", extra)
4296 }
4297
4298 n := extra
4299
4300 nameBuf := make([]byte, 10)
4301 for i := uint64(0); i < n; i++ {
4302 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4303 if err != nil {
4304 return err
4305 }
4306
4307 if !ok {
4308 // Field doesn't exist on this type, so ignore it
4309 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4310 return err
4311 }
4312 continue
4313 }
4314
4315 switch string(nameBuf[:nameLen]) {
4316 // t.Skip (bool) (bool)
4317 case "skip":
4318
4319 maj, extra, err = cr.ReadHeader()
4320 if err != nil {
4321 return err
4322 }
4323 if maj != cbg.MajOther {
4324 return fmt.Errorf("booleans must be major type 7")
4325 }
4326 switch extra {
4327 case 20:
4328 t.Skip = false
4329 case 21:
4330 t.Skip = true
4331 default:
4332 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
4333 }
4334 // t.Depth (int64) (int64)
4335 case "depth":
4336 {
4337 maj, extra, err := cr.ReadHeader()
4338 if err != nil {
4339 return err
4340 }
4341 var extraI int64
4342 switch maj {
4343 case cbg.MajUnsignedInt:
4344 extraI = int64(extra)
4345 if extraI < 0 {
4346 return fmt.Errorf("int64 positive overflow")
4347 }
4348 case cbg.MajNegativeInt:
4349 extraI = int64(extra)
4350 if extraI < 0 {
4351 return fmt.Errorf("int64 negative overflow")
4352 }
4353 extraI = -1 - extraI
4354 default:
4355 return fmt.Errorf("wrong type for int64 field: %d", maj)
4356 }
4357
4358 t.Depth = int64(extraI)
4359 }
4360 // t.Submodules (bool) (bool)
4361 case "submodules":
4362
4363 maj, extra, err = cr.ReadHeader()
4364 if err != nil {
4365 return err
4366 }
4367 if maj != cbg.MajOther {
4368 return fmt.Errorf("booleans must be major type 7")
4369 }
4370 switch extra {
4371 case 20:
4372 t.Submodules = false
4373 case 21:
4374 t.Submodules = true
4375 default:
4376 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
4377 }
4378
4379 default:
4380 // Field doesn't exist on this type, so ignore it
4381 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4382 return err
4383 }
4384 }
4385 }
4386
4387 return nil
4388}
4389func (t *Pipeline_ManualTriggerData) MarshalCBOR(w io.Writer) error {
4390 if t == nil {
4391 _, err := w.Write(cbg.CborNull)
4392 return err
4393 }
4394
4395 cw := cbg.NewCborWriter(w)
4396 fieldCount := 1
4397
4398 if t.Inputs == nil {
4399 fieldCount--
4400 }
4401
4402 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4403 return err
4404 }
4405
4406 // t.Inputs ([]*tangled.Pipeline_Pair) (slice)
4407 if t.Inputs != nil {
4408
4409 if len("inputs") > 1000000 {
4410 return xerrors.Errorf("Value in field \"inputs\" was too long")
4411 }
4412
4413 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
4414 return err
4415 }
4416 if _, err := cw.WriteString(string("inputs")); err != nil {
4417 return err
4418 }
4419
4420 if len(t.Inputs) > 8192 {
4421 return xerrors.Errorf("Slice value in field t.Inputs was too long")
4422 }
4423
4424 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
4425 return err
4426 }
4427 for _, v := range t.Inputs {
4428 if err := v.MarshalCBOR(cw); err != nil {
4429 return err
4430 }
4431
4432 }
4433 }
4434 return nil
4435}
4436
4437func (t *Pipeline_ManualTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
4438 *t = Pipeline_ManualTriggerData{}
4439
4440 cr := cbg.NewCborReader(r)
4441
4442 maj, extra, err := cr.ReadHeader()
4443 if err != nil {
4444 return err
4445 }
4446 defer func() {
4447 if err == io.EOF {
4448 err = io.ErrUnexpectedEOF
4449 }
4450 }()
4451
4452 if maj != cbg.MajMap {
4453 return fmt.Errorf("cbor input should be of type map")
4454 }
4455
4456 if extra > cbg.MaxLength {
4457 return fmt.Errorf("Pipeline_ManualTriggerData: map struct too large (%d)", extra)
4458 }
4459
4460 n := extra
4461
4462 nameBuf := make([]byte, 6)
4463 for i := uint64(0); i < n; i++ {
4464 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4465 if err != nil {
4466 return err
4467 }
4468
4469 if !ok {
4470 // Field doesn't exist on this type, so ignore it
4471 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4472 return err
4473 }
4474 continue
4475 }
4476
4477 switch string(nameBuf[:nameLen]) {
4478 // t.Inputs ([]*tangled.Pipeline_Pair) (slice)
4479 case "inputs":
4480
4481 maj, extra, err = cr.ReadHeader()
4482 if err != nil {
4483 return err
4484 }
4485
4486 if extra > 8192 {
4487 return fmt.Errorf("t.Inputs: array too large (%d)", extra)
4488 }
4489
4490 if maj != cbg.MajArray {
4491 return fmt.Errorf("expected cbor array")
4492 }
4493
4494 if extra > 0 {
4495 t.Inputs = make([]*Pipeline_Pair, extra)
4496 }
4497
4498 for i := 0; i < int(extra); i++ {
4499 {
4500 var maj byte
4501 var extra uint64
4502 var err error
4503 _ = maj
4504 _ = extra
4505 _ = err
4506
4507 {
4508
4509 b, err := cr.ReadByte()
4510 if err != nil {
4511 return err
4512 }
4513 if b != cbg.CborNull[0] {
4514 if err := cr.UnreadByte(); err != nil {
4515 return err
4516 }
4517 t.Inputs[i] = new(Pipeline_Pair)
4518 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
4519 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
4520 }
4521 }
4522
4523 }
4524
4525 }
4526 }
4527
4528 default:
4529 // Field doesn't exist on this type, so ignore it
4530 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4531 return err
4532 }
4533 }
4534 }
4535
4536 return nil
4537}
4538func (t *Pipeline_Pair) MarshalCBOR(w io.Writer) error {
4539 if t == nil {
4540 _, err := w.Write(cbg.CborNull)
4541 return err
4542 }
4543
4544 cw := cbg.NewCborWriter(w)
4545
4546 if _, err := cw.Write([]byte{162}); err != nil {
4547 return err
4548 }
4549
4550 // t.Key (string) (string)
4551 if len("key") > 1000000 {
4552 return xerrors.Errorf("Value in field \"key\" was too long")
4553 }
4554
4555 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
4556 return err
4557 }
4558 if _, err := cw.WriteString(string("key")); err != nil {
4559 return err
4560 }
4561
4562 if len(t.Key) > 1000000 {
4563 return xerrors.Errorf("Value in field t.Key was too long")
4564 }
4565
4566 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
4567 return err
4568 }
4569 if _, err := cw.WriteString(string(t.Key)); err != nil {
4570 return err
4571 }
4572
4573 // t.Value (string) (string)
4574 if len("value") > 1000000 {
4575 return xerrors.Errorf("Value in field \"value\" was too long")
4576 }
4577
4578 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
4579 return err
4580 }
4581 if _, err := cw.WriteString(string("value")); err != nil {
4582 return err
4583 }
4584
4585 if len(t.Value) > 1000000 {
4586 return xerrors.Errorf("Value in field t.Value was too long")
4587 }
4588
4589 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
4590 return err
4591 }
4592 if _, err := cw.WriteString(string(t.Value)); err != nil {
4593 return err
4594 }
4595 return nil
4596}
4597
4598func (t *Pipeline_Pair) UnmarshalCBOR(r io.Reader) (err error) {
4599 *t = Pipeline_Pair{}
4600
4601 cr := cbg.NewCborReader(r)
4602
4603 maj, extra, err := cr.ReadHeader()
4604 if err != nil {
4605 return err
4606 }
4607 defer func() {
4608 if err == io.EOF {
4609 err = io.ErrUnexpectedEOF
4610 }
4611 }()
4612
4613 if maj != cbg.MajMap {
4614 return fmt.Errorf("cbor input should be of type map")
4615 }
4616
4617 if extra > cbg.MaxLength {
4618 return fmt.Errorf("Pipeline_Pair: map struct too large (%d)", extra)
4619 }
4620
4621 n := extra
4622
4623 nameBuf := make([]byte, 5)
4624 for i := uint64(0); i < n; i++ {
4625 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4626 if err != nil {
4627 return err
4628 }
4629
4630 if !ok {
4631 // Field doesn't exist on this type, so ignore it
4632 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4633 return err
4634 }
4635 continue
4636 }
4637
4638 switch string(nameBuf[:nameLen]) {
4639 // t.Key (string) (string)
4640 case "key":
4641
4642 {
4643 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4644 if err != nil {
4645 return err
4646 }
4647
4648 t.Key = string(sval)
4649 }
4650 // t.Value (string) (string)
4651 case "value":
4652
4653 {
4654 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4655 if err != nil {
4656 return err
4657 }
4658
4659 t.Value = string(sval)
4660 }
4661
4662 default:
4663 // Field doesn't exist on this type, so ignore it
4664 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4665 return err
4666 }
4667 }
4668 }
4669
4670 return nil
4671}
4672func (t *Pipeline_PullRequestTriggerData) MarshalCBOR(w io.Writer) error {
4673 if t == nil {
4674 _, err := w.Write(cbg.CborNull)
4675 return err
4676 }
4677
4678 cw := cbg.NewCborWriter(w)
4679
4680 if _, err := cw.Write([]byte{164}); err != nil {
4681 return err
4682 }
4683
4684 // t.Action (string) (string)
4685 if len("action") > 1000000 {
4686 return xerrors.Errorf("Value in field \"action\" was too long")
4687 }
4688
4689 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("action"))); err != nil {
4690 return err
4691 }
4692 if _, err := cw.WriteString(string("action")); err != nil {
4693 return err
4694 }
4695
4696 if len(t.Action) > 1000000 {
4697 return xerrors.Errorf("Value in field t.Action was too long")
4698 }
4699
4700 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Action))); err != nil {
4701 return err
4702 }
4703 if _, err := cw.WriteString(string(t.Action)); err != nil {
4704 return err
4705 }
4706
4707 // t.SourceSha (string) (string)
4708 if len("sourceSha") > 1000000 {
4709 return xerrors.Errorf("Value in field \"sourceSha\" was too long")
4710 }
4711
4712 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceSha"))); err != nil {
4713 return err
4714 }
4715 if _, err := cw.WriteString(string("sourceSha")); err != nil {
4716 return err
4717 }
4718
4719 if len(t.SourceSha) > 1000000 {
4720 return xerrors.Errorf("Value in field t.SourceSha was too long")
4721 }
4722
4723 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceSha))); err != nil {
4724 return err
4725 }
4726 if _, err := cw.WriteString(string(t.SourceSha)); err != nil {
4727 return err
4728 }
4729
4730 // t.SourceBranch (string) (string)
4731 if len("sourceBranch") > 1000000 {
4732 return xerrors.Errorf("Value in field \"sourceBranch\" was too long")
4733 }
4734
4735 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceBranch"))); err != nil {
4736 return err
4737 }
4738 if _, err := cw.WriteString(string("sourceBranch")); err != nil {
4739 return err
4740 }
4741
4742 if len(t.SourceBranch) > 1000000 {
4743 return xerrors.Errorf("Value in field t.SourceBranch was too long")
4744 }
4745
4746 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceBranch))); err != nil {
4747 return err
4748 }
4749 if _, err := cw.WriteString(string(t.SourceBranch)); err != nil {
4750 return err
4751 }
4752
4753 // t.TargetBranch (string) (string)
4754 if len("targetBranch") > 1000000 {
4755 return xerrors.Errorf("Value in field \"targetBranch\" was too long")
4756 }
4757
4758 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil {
4759 return err
4760 }
4761 if _, err := cw.WriteString(string("targetBranch")); err != nil {
4762 return err
4763 }
4764
4765 if len(t.TargetBranch) > 1000000 {
4766 return xerrors.Errorf("Value in field t.TargetBranch was too long")
4767 }
4768
4769 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil {
4770 return err
4771 }
4772 if _, err := cw.WriteString(string(t.TargetBranch)); err != nil {
4773 return err
4774 }
4775 return nil
4776}
4777
4778func (t *Pipeline_PullRequestTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
4779 *t = Pipeline_PullRequestTriggerData{}
4780
4781 cr := cbg.NewCborReader(r)
4782
4783 maj, extra, err := cr.ReadHeader()
4784 if err != nil {
4785 return err
4786 }
4787 defer func() {
4788 if err == io.EOF {
4789 err = io.ErrUnexpectedEOF
4790 }
4791 }()
4792
4793 if maj != cbg.MajMap {
4794 return fmt.Errorf("cbor input should be of type map")
4795 }
4796
4797 if extra > cbg.MaxLength {
4798 return fmt.Errorf("Pipeline_PullRequestTriggerData: map struct too large (%d)", extra)
4799 }
4800
4801 n := extra
4802
4803 nameBuf := make([]byte, 12)
4804 for i := uint64(0); i < n; i++ {
4805 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4806 if err != nil {
4807 return err
4808 }
4809
4810 if !ok {
4811 // Field doesn't exist on this type, so ignore it
4812 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4813 return err
4814 }
4815 continue
4816 }
4817
4818 switch string(nameBuf[:nameLen]) {
4819 // t.Action (string) (string)
4820 case "action":
4821
4822 {
4823 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4824 if err != nil {
4825 return err
4826 }
4827
4828 t.Action = string(sval)
4829 }
4830 // t.SourceSha (string) (string)
4831 case "sourceSha":
4832
4833 {
4834 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4835 if err != nil {
4836 return err
4837 }
4838
4839 t.SourceSha = string(sval)
4840 }
4841 // t.SourceBranch (string) (string)
4842 case "sourceBranch":
4843
4844 {
4845 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4846 if err != nil {
4847 return err
4848 }
4849
4850 t.SourceBranch = string(sval)
4851 }
4852 // t.TargetBranch (string) (string)
4853 case "targetBranch":
4854
4855 {
4856 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4857 if err != nil {
4858 return err
4859 }
4860
4861 t.TargetBranch = string(sval)
4862 }
4863
4864 default:
4865 // Field doesn't exist on this type, so ignore it
4866 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4867 return err
4868 }
4869 }
4870 }
4871
4872 return nil
4873}
4874func (t *Pipeline_PushTriggerData) MarshalCBOR(w io.Writer) error {
4875 if t == nil {
4876 _, err := w.Write(cbg.CborNull)
4877 return err
4878 }
4879
4880 cw := cbg.NewCborWriter(w)
4881
4882 if _, err := cw.Write([]byte{163}); err != nil {
4883 return err
4884 }
4885
4886 // t.Ref (string) (string)
4887 if len("ref") > 1000000 {
4888 return xerrors.Errorf("Value in field \"ref\" was too long")
4889 }
4890
4891 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
4892 return err
4893 }
4894 if _, err := cw.WriteString(string("ref")); err != nil {
4895 return err
4896 }
4897
4898 if len(t.Ref) > 1000000 {
4899 return xerrors.Errorf("Value in field t.Ref was too long")
4900 }
4901
4902 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
4903 return err
4904 }
4905 if _, err := cw.WriteString(string(t.Ref)); err != nil {
4906 return err
4907 }
4908
4909 // t.NewSha (string) (string)
4910 if len("newSha") > 1000000 {
4911 return xerrors.Errorf("Value in field \"newSha\" was too long")
4912 }
4913
4914 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
4915 return err
4916 }
4917 if _, err := cw.WriteString(string("newSha")); err != nil {
4918 return err
4919 }
4920
4921 if len(t.NewSha) > 1000000 {
4922 return xerrors.Errorf("Value in field t.NewSha was too long")
4923 }
4924
4925 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
4926 return err
4927 }
4928 if _, err := cw.WriteString(string(t.NewSha)); err != nil {
4929 return err
4930 }
4931
4932 // t.OldSha (string) (string)
4933 if len("oldSha") > 1000000 {
4934 return xerrors.Errorf("Value in field \"oldSha\" was too long")
4935 }
4936
4937 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
4938 return err
4939 }
4940 if _, err := cw.WriteString(string("oldSha")); err != nil {
4941 return err
4942 }
4943
4944 if len(t.OldSha) > 1000000 {
4945 return xerrors.Errorf("Value in field t.OldSha was too long")
4946 }
4947
4948 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
4949 return err
4950 }
4951 if _, err := cw.WriteString(string(t.OldSha)); err != nil {
4952 return err
4953 }
4954 return nil
4955}
4956
4957func (t *Pipeline_PushTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
4958 *t = Pipeline_PushTriggerData{}
4959
4960 cr := cbg.NewCborReader(r)
4961
4962 maj, extra, err := cr.ReadHeader()
4963 if err != nil {
4964 return err
4965 }
4966 defer func() {
4967 if err == io.EOF {
4968 err = io.ErrUnexpectedEOF
4969 }
4970 }()
4971
4972 if maj != cbg.MajMap {
4973 return fmt.Errorf("cbor input should be of type map")
4974 }
4975
4976 if extra > cbg.MaxLength {
4977 return fmt.Errorf("Pipeline_PushTriggerData: map struct too large (%d)", extra)
4978 }
4979
4980 n := extra
4981
4982 nameBuf := make([]byte, 6)
4983 for i := uint64(0); i < n; i++ {
4984 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4985 if err != nil {
4986 return err
4987 }
4988
4989 if !ok {
4990 // Field doesn't exist on this type, so ignore it
4991 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4992 return err
4993 }
4994 continue
4995 }
4996
4997 switch string(nameBuf[:nameLen]) {
4998 // t.Ref (string) (string)
4999 case "ref":
5000
5001 {
5002 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5003 if err != nil {
5004 return err
5005 }
5006
5007 t.Ref = string(sval)
5008 }
5009 // t.NewSha (string) (string)
5010 case "newSha":
5011
5012 {
5013 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5014 if err != nil {
5015 return err
5016 }
5017
5018 t.NewSha = string(sval)
5019 }
5020 // t.OldSha (string) (string)
5021 case "oldSha":
5022
5023 {
5024 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5025 if err != nil {
5026 return err
5027 }
5028
5029 t.OldSha = string(sval)
5030 }
5031
5032 default:
5033 // Field doesn't exist on this type, so ignore it
5034 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5035 return err
5036 }
5037 }
5038 }
5039
5040 return nil
5041}
5042func (t *PipelineStatus) MarshalCBOR(w io.Writer) error {
5043 if t == nil {
5044 _, err := w.Write(cbg.CborNull)
5045 return err
5046 }
5047
5048 cw := cbg.NewCborWriter(w)
5049 fieldCount := 7
5050
5051 if t.Error == nil {
5052 fieldCount--
5053 }
5054
5055 if t.ExitCode == nil {
5056 fieldCount--
5057 }
5058
5059 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5060 return err
5061 }
5062
5063 // t.LexiconTypeID (string) (string)
5064 if len("$type") > 1000000 {
5065 return xerrors.Errorf("Value in field \"$type\" was too long")
5066 }
5067
5068 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5069 return err
5070 }
5071 if _, err := cw.WriteString(string("$type")); err != nil {
5072 return err
5073 }
5074
5075 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline.status"))); err != nil {
5076 return err
5077 }
5078 if _, err := cw.WriteString(string("sh.tangled.pipeline.status")); err != nil {
5079 return err
5080 }
5081
5082 // t.Error (string) (string)
5083 if t.Error != nil {
5084
5085 if len("error") > 1000000 {
5086 return xerrors.Errorf("Value in field \"error\" was too long")
5087 }
5088
5089 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("error"))); err != nil {
5090 return err
5091 }
5092 if _, err := cw.WriteString(string("error")); err != nil {
5093 return err
5094 }
5095
5096 if t.Error == nil {
5097 if _, err := cw.Write(cbg.CborNull); err != nil {
5098 return err
5099 }
5100 } else {
5101 if len(*t.Error) > 1000000 {
5102 return xerrors.Errorf("Value in field t.Error was too long")
5103 }
5104
5105 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Error))); err != nil {
5106 return err
5107 }
5108 if _, err := cw.WriteString(string(*t.Error)); err != nil {
5109 return err
5110 }
5111 }
5112 }
5113
5114 // t.Status (string) (string)
5115 if len("status") > 1000000 {
5116 return xerrors.Errorf("Value in field \"status\" was too long")
5117 }
5118
5119 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
5120 return err
5121 }
5122 if _, err := cw.WriteString(string("status")); err != nil {
5123 return err
5124 }
5125
5126 if len(t.Status) > 1000000 {
5127 return xerrors.Errorf("Value in field t.Status was too long")
5128 }
5129
5130 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
5131 return err
5132 }
5133 if _, err := cw.WriteString(string(t.Status)); err != nil {
5134 return err
5135 }
5136
5137 // t.ExitCode (int64) (int64)
5138 if t.ExitCode != nil {
5139
5140 if len("exitCode") > 1000000 {
5141 return xerrors.Errorf("Value in field \"exitCode\" was too long")
5142 }
5143
5144 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("exitCode"))); err != nil {
5145 return err
5146 }
5147 if _, err := cw.WriteString(string("exitCode")); err != nil {
5148 return err
5149 }
5150
5151 if t.ExitCode == nil {
5152 if _, err := cw.Write(cbg.CborNull); err != nil {
5153 return err
5154 }
5155 } else {
5156 if *t.ExitCode >= 0 {
5157 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.ExitCode)); err != nil {
5158 return err
5159 }
5160 } else {
5161 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.ExitCode-1)); err != nil {
5162 return err
5163 }
5164 }
5165 }
5166
5167 }
5168
5169 // t.Pipeline (string) (string)
5170 if len("pipeline") > 1000000 {
5171 return xerrors.Errorf("Value in field \"pipeline\" was too long")
5172 }
5173
5174 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pipeline"))); err != nil {
5175 return err
5176 }
5177 if _, err := cw.WriteString(string("pipeline")); err != nil {
5178 return err
5179 }
5180
5181 if len(t.Pipeline) > 1000000 {
5182 return xerrors.Errorf("Value in field t.Pipeline was too long")
5183 }
5184
5185 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pipeline))); err != nil {
5186 return err
5187 }
5188 if _, err := cw.WriteString(string(t.Pipeline)); err != nil {
5189 return err
5190 }
5191
5192 // t.Workflow (string) (string)
5193 if len("workflow") > 1000000 {
5194 return xerrors.Errorf("Value in field \"workflow\" was too long")
5195 }
5196
5197 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil {
5198 return err
5199 }
5200 if _, err := cw.WriteString(string("workflow")); err != nil {
5201 return err
5202 }
5203
5204 if len(t.Workflow) > 1000000 {
5205 return xerrors.Errorf("Value in field t.Workflow was too long")
5206 }
5207
5208 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil {
5209 return err
5210 }
5211 if _, err := cw.WriteString(string(t.Workflow)); err != nil {
5212 return err
5213 }
5214
5215 // t.CreatedAt (string) (string)
5216 if len("createdAt") > 1000000 {
5217 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5218 }
5219
5220 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5221 return err
5222 }
5223 if _, err := cw.WriteString(string("createdAt")); err != nil {
5224 return err
5225 }
5226
5227 if len(t.CreatedAt) > 1000000 {
5228 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5229 }
5230
5231 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5232 return err
5233 }
5234 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5235 return err
5236 }
5237 return nil
5238}
5239
5240func (t *PipelineStatus) UnmarshalCBOR(r io.Reader) (err error) {
5241 *t = PipelineStatus{}
5242
5243 cr := cbg.NewCborReader(r)
5244
5245 maj, extra, err := cr.ReadHeader()
5246 if err != nil {
5247 return err
5248 }
5249 defer func() {
5250 if err == io.EOF {
5251 err = io.ErrUnexpectedEOF
5252 }
5253 }()
5254
5255 if maj != cbg.MajMap {
5256 return fmt.Errorf("cbor input should be of type map")
5257 }
5258
5259 if extra > cbg.MaxLength {
5260 return fmt.Errorf("PipelineStatus: map struct too large (%d)", extra)
5261 }
5262
5263 n := extra
5264
5265 nameBuf := make([]byte, 9)
5266 for i := uint64(0); i < n; i++ {
5267 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5268 if err != nil {
5269 return err
5270 }
5271
5272 if !ok {
5273 // Field doesn't exist on this type, so ignore it
5274 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5275 return err
5276 }
5277 continue
5278 }
5279
5280 switch string(nameBuf[:nameLen]) {
5281 // t.LexiconTypeID (string) (string)
5282 case "$type":
5283
5284 {
5285 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5286 if err != nil {
5287 return err
5288 }
5289
5290 t.LexiconTypeID = string(sval)
5291 }
5292 // t.Error (string) (string)
5293 case "error":
5294
5295 {
5296 b, err := cr.ReadByte()
5297 if err != nil {
5298 return err
5299 }
5300 if b != cbg.CborNull[0] {
5301 if err := cr.UnreadByte(); err != nil {
5302 return err
5303 }
5304
5305 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5306 if err != nil {
5307 return err
5308 }
5309
5310 t.Error = (*string)(&sval)
5311 }
5312 }
5313 // t.Status (string) (string)
5314 case "status":
5315
5316 {
5317 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5318 if err != nil {
5319 return err
5320 }
5321
5322 t.Status = string(sval)
5323 }
5324 // t.ExitCode (int64) (int64)
5325 case "exitCode":
5326 {
5327
5328 b, err := cr.ReadByte()
5329 if err != nil {
5330 return err
5331 }
5332 if b != cbg.CborNull[0] {
5333 if err := cr.UnreadByte(); err != nil {
5334 return err
5335 }
5336 maj, extra, err := cr.ReadHeader()
5337 if err != nil {
5338 return err
5339 }
5340 var extraI int64
5341 switch maj {
5342 case cbg.MajUnsignedInt:
5343 extraI = int64(extra)
5344 if extraI < 0 {
5345 return fmt.Errorf("int64 positive overflow")
5346 }
5347 case cbg.MajNegativeInt:
5348 extraI = int64(extra)
5349 if extraI < 0 {
5350 return fmt.Errorf("int64 negative overflow")
5351 }
5352 extraI = -1 - extraI
5353 default:
5354 return fmt.Errorf("wrong type for int64 field: %d", maj)
5355 }
5356
5357 t.ExitCode = (*int64)(&extraI)
5358 }
5359 }
5360 // t.Pipeline (string) (string)
5361 case "pipeline":
5362
5363 {
5364 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5365 if err != nil {
5366 return err
5367 }
5368
5369 t.Pipeline = string(sval)
5370 }
5371 // t.Workflow (string) (string)
5372 case "workflow":
5373
5374 {
5375 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5376 if err != nil {
5377 return err
5378 }
5379
5380 t.Workflow = string(sval)
5381 }
5382 // t.CreatedAt (string) (string)
5383 case "createdAt":
5384
5385 {
5386 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5387 if err != nil {
5388 return err
5389 }
5390
5391 t.CreatedAt = string(sval)
5392 }
5393
5394 default:
5395 // Field doesn't exist on this type, so ignore it
5396 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5397 return err
5398 }
5399 }
5400 }
5401
5402 return nil
5403}
5404func (t *Pipeline_TriggerMetadata) MarshalCBOR(w io.Writer) error {
5405 if t == nil {
5406 _, err := w.Write(cbg.CborNull)
5407 return err
5408 }
5409
5410 cw := cbg.NewCborWriter(w)
5411 fieldCount := 5
5412
5413 if t.Manual == nil {
5414 fieldCount--
5415 }
5416
5417 if t.PullRequest == nil {
5418 fieldCount--
5419 }
5420
5421 if t.Push == nil {
5422 fieldCount--
5423 }
5424
5425 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5426 return err
5427 }
5428
5429 // t.Kind (string) (string)
5430 if len("kind") > 1000000 {
5431 return xerrors.Errorf("Value in field \"kind\" was too long")
5432 }
5433
5434 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("kind"))); err != nil {
5435 return err
5436 }
5437 if _, err := cw.WriteString(string("kind")); err != nil {
5438 return err
5439 }
5440
5441 if len(t.Kind) > 1000000 {
5442 return xerrors.Errorf("Value in field t.Kind was too long")
5443 }
5444
5445 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Kind))); err != nil {
5446 return err
5447 }
5448 if _, err := cw.WriteString(string(t.Kind)); err != nil {
5449 return err
5450 }
5451
5452 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
5453 if t.Push != nil {
5454
5455 if len("push") > 1000000 {
5456 return xerrors.Errorf("Value in field \"push\" was too long")
5457 }
5458
5459 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("push"))); err != nil {
5460 return err
5461 }
5462 if _, err := cw.WriteString(string("push")); err != nil {
5463 return err
5464 }
5465
5466 if err := t.Push.MarshalCBOR(cw); err != nil {
5467 return err
5468 }
5469 }
5470
5471 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
5472 if len("repo") > 1000000 {
5473 return xerrors.Errorf("Value in field \"repo\" was too long")
5474 }
5475
5476 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5477 return err
5478 }
5479 if _, err := cw.WriteString(string("repo")); err != nil {
5480 return err
5481 }
5482
5483 if err := t.Repo.MarshalCBOR(cw); err != nil {
5484 return err
5485 }
5486
5487 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
5488 if t.Manual != nil {
5489
5490 if len("manual") > 1000000 {
5491 return xerrors.Errorf("Value in field \"manual\" was too long")
5492 }
5493
5494 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("manual"))); err != nil {
5495 return err
5496 }
5497 if _, err := cw.WriteString(string("manual")); err != nil {
5498 return err
5499 }
5500
5501 if err := t.Manual.MarshalCBOR(cw); err != nil {
5502 return err
5503 }
5504 }
5505
5506 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
5507 if t.PullRequest != nil {
5508
5509 if len("pullRequest") > 1000000 {
5510 return xerrors.Errorf("Value in field \"pullRequest\" was too long")
5511 }
5512
5513 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullRequest"))); err != nil {
5514 return err
5515 }
5516 if _, err := cw.WriteString(string("pullRequest")); err != nil {
5517 return err
5518 }
5519
5520 if err := t.PullRequest.MarshalCBOR(cw); err != nil {
5521 return err
5522 }
5523 }
5524 return nil
5525}
5526
5527func (t *Pipeline_TriggerMetadata) UnmarshalCBOR(r io.Reader) (err error) {
5528 *t = Pipeline_TriggerMetadata{}
5529
5530 cr := cbg.NewCborReader(r)
5531
5532 maj, extra, err := cr.ReadHeader()
5533 if err != nil {
5534 return err
5535 }
5536 defer func() {
5537 if err == io.EOF {
5538 err = io.ErrUnexpectedEOF
5539 }
5540 }()
5541
5542 if maj != cbg.MajMap {
5543 return fmt.Errorf("cbor input should be of type map")
5544 }
5545
5546 if extra > cbg.MaxLength {
5547 return fmt.Errorf("Pipeline_TriggerMetadata: map struct too large (%d)", extra)
5548 }
5549
5550 n := extra
5551
5552 nameBuf := make([]byte, 11)
5553 for i := uint64(0); i < n; i++ {
5554 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5555 if err != nil {
5556 return err
5557 }
5558
5559 if !ok {
5560 // Field doesn't exist on this type, so ignore it
5561 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5562 return err
5563 }
5564 continue
5565 }
5566
5567 switch string(nameBuf[:nameLen]) {
5568 // t.Kind (string) (string)
5569 case "kind":
5570
5571 {
5572 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5573 if err != nil {
5574 return err
5575 }
5576
5577 t.Kind = string(sval)
5578 }
5579 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
5580 case "push":
5581
5582 {
5583
5584 b, err := cr.ReadByte()
5585 if err != nil {
5586 return err
5587 }
5588 if b != cbg.CborNull[0] {
5589 if err := cr.UnreadByte(); err != nil {
5590 return err
5591 }
5592 t.Push = new(Pipeline_PushTriggerData)
5593 if err := t.Push.UnmarshalCBOR(cr); err != nil {
5594 return xerrors.Errorf("unmarshaling t.Push pointer: %w", err)
5595 }
5596 }
5597
5598 }
5599 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
5600 case "repo":
5601
5602 {
5603
5604 b, err := cr.ReadByte()
5605 if err != nil {
5606 return err
5607 }
5608 if b != cbg.CborNull[0] {
5609 if err := cr.UnreadByte(); err != nil {
5610 return err
5611 }
5612 t.Repo = new(Pipeline_TriggerRepo)
5613 if err := t.Repo.UnmarshalCBOR(cr); err != nil {
5614 return xerrors.Errorf("unmarshaling t.Repo pointer: %w", err)
5615 }
5616 }
5617
5618 }
5619 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
5620 case "manual":
5621
5622 {
5623
5624 b, err := cr.ReadByte()
5625 if err != nil {
5626 return err
5627 }
5628 if b != cbg.CborNull[0] {
5629 if err := cr.UnreadByte(); err != nil {
5630 return err
5631 }
5632 t.Manual = new(Pipeline_ManualTriggerData)
5633 if err := t.Manual.UnmarshalCBOR(cr); err != nil {
5634 return xerrors.Errorf("unmarshaling t.Manual pointer: %w", err)
5635 }
5636 }
5637
5638 }
5639 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
5640 case "pullRequest":
5641
5642 {
5643
5644 b, err := cr.ReadByte()
5645 if err != nil {
5646 return err
5647 }
5648 if b != cbg.CborNull[0] {
5649 if err := cr.UnreadByte(); err != nil {
5650 return err
5651 }
5652 t.PullRequest = new(Pipeline_PullRequestTriggerData)
5653 if err := t.PullRequest.UnmarshalCBOR(cr); err != nil {
5654 return xerrors.Errorf("unmarshaling t.PullRequest pointer: %w", err)
5655 }
5656 }
5657
5658 }
5659
5660 default:
5661 // Field doesn't exist on this type, so ignore it
5662 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5663 return err
5664 }
5665 }
5666 }
5667
5668 return nil
5669}
5670func (t *Pipeline_TriggerRepo) MarshalCBOR(w io.Writer) error {
5671 if t == nil {
5672 _, err := w.Write(cbg.CborNull)
5673 return err
5674 }
5675
5676 cw := cbg.NewCborWriter(w)
5677
5678 if _, err := cw.Write([]byte{164}); err != nil {
5679 return err
5680 }
5681
5682 // t.Did (string) (string)
5683 if len("did") > 1000000 {
5684 return xerrors.Errorf("Value in field \"did\" was too long")
5685 }
5686
5687 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil {
5688 return err
5689 }
5690 if _, err := cw.WriteString(string("did")); err != nil {
5691 return err
5692 }
5693
5694 if len(t.Did) > 1000000 {
5695 return xerrors.Errorf("Value in field t.Did was too long")
5696 }
5697
5698 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil {
5699 return err
5700 }
5701 if _, err := cw.WriteString(string(t.Did)); err != nil {
5702 return err
5703 }
5704
5705 // t.Knot (string) (string)
5706 if len("knot") > 1000000 {
5707 return xerrors.Errorf("Value in field \"knot\" was too long")
5708 }
5709
5710 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
5711 return err
5712 }
5713 if _, err := cw.WriteString(string("knot")); err != nil {
5714 return err
5715 }
5716
5717 if len(t.Knot) > 1000000 {
5718 return xerrors.Errorf("Value in field t.Knot was too long")
5719 }
5720
5721 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
5722 return err
5723 }
5724 if _, err := cw.WriteString(string(t.Knot)); err != nil {
5725 return err
5726 }
5727
5728 // t.Repo (string) (string)
5729 if len("repo") > 1000000 {
5730 return xerrors.Errorf("Value in field \"repo\" was too long")
5731 }
5732
5733 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5734 return err
5735 }
5736 if _, err := cw.WriteString(string("repo")); err != nil {
5737 return err
5738 }
5739
5740 if len(t.Repo) > 1000000 {
5741 return xerrors.Errorf("Value in field t.Repo was too long")
5742 }
5743
5744 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
5745 return err
5746 }
5747 if _, err := cw.WriteString(string(t.Repo)); err != nil {
5748 return err
5749 }
5750
5751 // t.DefaultBranch (string) (string)
5752 if len("defaultBranch") > 1000000 {
5753 return xerrors.Errorf("Value in field \"defaultBranch\" was too long")
5754 }
5755
5756 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("defaultBranch"))); err != nil {
5757 return err
5758 }
5759 if _, err := cw.WriteString(string("defaultBranch")); err != nil {
5760 return err
5761 }
5762
5763 if len(t.DefaultBranch) > 1000000 {
5764 return xerrors.Errorf("Value in field t.DefaultBranch was too long")
5765 }
5766
5767 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.DefaultBranch))); err != nil {
5768 return err
5769 }
5770 if _, err := cw.WriteString(string(t.DefaultBranch)); err != nil {
5771 return err
5772 }
5773 return nil
5774}
5775
5776func (t *Pipeline_TriggerRepo) UnmarshalCBOR(r io.Reader) (err error) {
5777 *t = Pipeline_TriggerRepo{}
5778
5779 cr := cbg.NewCborReader(r)
5780
5781 maj, extra, err := cr.ReadHeader()
5782 if err != nil {
5783 return err
5784 }
5785 defer func() {
5786 if err == io.EOF {
5787 err = io.ErrUnexpectedEOF
5788 }
5789 }()
5790
5791 if maj != cbg.MajMap {
5792 return fmt.Errorf("cbor input should be of type map")
5793 }
5794
5795 if extra > cbg.MaxLength {
5796 return fmt.Errorf("Pipeline_TriggerRepo: map struct too large (%d)", extra)
5797 }
5798
5799 n := extra
5800
5801 nameBuf := make([]byte, 13)
5802 for i := uint64(0); i < n; i++ {
5803 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5804 if err != nil {
5805 return err
5806 }
5807
5808 if !ok {
5809 // Field doesn't exist on this type, so ignore it
5810 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5811 return err
5812 }
5813 continue
5814 }
5815
5816 switch string(nameBuf[:nameLen]) {
5817 // t.Did (string) (string)
5818 case "did":
5819
5820 {
5821 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5822 if err != nil {
5823 return err
5824 }
5825
5826 t.Did = string(sval)
5827 }
5828 // t.Knot (string) (string)
5829 case "knot":
5830
5831 {
5832 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5833 if err != nil {
5834 return err
5835 }
5836
5837 t.Knot = string(sval)
5838 }
5839 // t.Repo (string) (string)
5840 case "repo":
5841
5842 {
5843 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5844 if err != nil {
5845 return err
5846 }
5847
5848 t.Repo = string(sval)
5849 }
5850 // t.DefaultBranch (string) (string)
5851 case "defaultBranch":
5852
5853 {
5854 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5855 if err != nil {
5856 return err
5857 }
5858
5859 t.DefaultBranch = string(sval)
5860 }
5861
5862 default:
5863 // Field doesn't exist on this type, so ignore it
5864 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5865 return err
5866 }
5867 }
5868 }
5869
5870 return nil
5871}
5872func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error {
5873 if t == nil {
5874 _, err := w.Write(cbg.CborNull)
5875 return err
5876 }
5877
5878 cw := cbg.NewCborWriter(w)
5879
5880 if _, err := cw.Write([]byte{164}); err != nil {
5881 return err
5882 }
5883
5884 // t.Raw (string) (string)
5885 if len("raw") > 1000000 {
5886 return xerrors.Errorf("Value in field \"raw\" was too long")
5887 }
5888
5889 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("raw"))); err != nil {
5890 return err
5891 }
5892 if _, err := cw.WriteString(string("raw")); err != nil {
5893 return err
5894 }
5895
5896 if len(t.Raw) > 1000000 {
5897 return xerrors.Errorf("Value in field t.Raw was too long")
5898 }
5899
5900 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Raw))); err != nil {
5901 return err
5902 }
5903 if _, err := cw.WriteString(string(t.Raw)); err != nil {
5904 return err
5905 }
5906
5907 // t.Name (string) (string)
5908 if len("name") > 1000000 {
5909 return xerrors.Errorf("Value in field \"name\" was too long")
5910 }
5911
5912 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5913 return err
5914 }
5915 if _, err := cw.WriteString(string("name")); err != nil {
5916 return err
5917 }
5918
5919 if len(t.Name) > 1000000 {
5920 return xerrors.Errorf("Value in field t.Name was too long")
5921 }
5922
5923 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5924 return err
5925 }
5926 if _, err := cw.WriteString(string(t.Name)); err != nil {
5927 return err
5928 }
5929
5930 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
5931 if len("clone") > 1000000 {
5932 return xerrors.Errorf("Value in field \"clone\" was too long")
5933 }
5934
5935 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil {
5936 return err
5937 }
5938 if _, err := cw.WriteString(string("clone")); err != nil {
5939 return err
5940 }
5941
5942 if err := t.Clone.MarshalCBOR(cw); err != nil {
5943 return err
5944 }
5945
5946 // t.Engine (string) (string)
5947 if len("engine") > 1000000 {
5948 return xerrors.Errorf("Value in field \"engine\" was too long")
5949 }
5950
5951 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("engine"))); err != nil {
5952 return err
5953 }
5954 if _, err := cw.WriteString(string("engine")); err != nil {
5955 return err
5956 }
5957
5958 if len(t.Engine) > 1000000 {
5959 return xerrors.Errorf("Value in field t.Engine was too long")
5960 }
5961
5962 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Engine))); err != nil {
5963 return err
5964 }
5965 if _, err := cw.WriteString(string(t.Engine)); err != nil {
5966 return err
5967 }
5968 return nil
5969}
5970
5971func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) {
5972 *t = Pipeline_Workflow{}
5973
5974 cr := cbg.NewCborReader(r)
5975
5976 maj, extra, err := cr.ReadHeader()
5977 if err != nil {
5978 return err
5979 }
5980 defer func() {
5981 if err == io.EOF {
5982 err = io.ErrUnexpectedEOF
5983 }
5984 }()
5985
5986 if maj != cbg.MajMap {
5987 return fmt.Errorf("cbor input should be of type map")
5988 }
5989
5990 if extra > cbg.MaxLength {
5991 return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra)
5992 }
5993
5994 n := extra
5995
5996 nameBuf := make([]byte, 6)
5997 for i := uint64(0); i < n; i++ {
5998 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5999 if err != nil {
6000 return err
6001 }
6002
6003 if !ok {
6004 // Field doesn't exist on this type, so ignore it
6005 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6006 return err
6007 }
6008 continue
6009 }
6010
6011 switch string(nameBuf[:nameLen]) {
6012 // t.Raw (string) (string)
6013 case "raw":
6014
6015 {
6016 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6017 if err != nil {
6018 return err
6019 }
6020
6021 t.Raw = string(sval)
6022 }
6023 // t.Name (string) (string)
6024 case "name":
6025
6026 {
6027 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6028 if err != nil {
6029 return err
6030 }
6031
6032 t.Name = string(sval)
6033 }
6034 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
6035 case "clone":
6036
6037 {
6038
6039 b, err := cr.ReadByte()
6040 if err != nil {
6041 return err
6042 }
6043 if b != cbg.CborNull[0] {
6044 if err := cr.UnreadByte(); err != nil {
6045 return err
6046 }
6047 t.Clone = new(Pipeline_CloneOpts)
6048 if err := t.Clone.UnmarshalCBOR(cr); err != nil {
6049 return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err)
6050 }
6051 }
6052
6053 }
6054 // t.Engine (string) (string)
6055 case "engine":
6056
6057 {
6058 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6059 if err != nil {
6060 return err
6061 }
6062
6063 t.Engine = string(sval)
6064 }
6065
6066 default:
6067 // Field doesn't exist on this type, so ignore it
6068 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6069 return err
6070 }
6071 }
6072 }
6073
6074 return nil
6075}
6076func (t *PublicKey) MarshalCBOR(w io.Writer) error {
6077 if t == nil {
6078 _, err := w.Write(cbg.CborNull)
6079 return err
6080 }
6081
6082 cw := cbg.NewCborWriter(w)
6083
6084 if _, err := cw.Write([]byte{164}); err != nil {
6085 return err
6086 }
6087
6088 // t.Key (string) (string)
6089 if len("key") > 1000000 {
6090 return xerrors.Errorf("Value in field \"key\" was too long")
6091 }
6092
6093 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
6094 return err
6095 }
6096 if _, err := cw.WriteString(string("key")); err != nil {
6097 return err
6098 }
6099
6100 if len(t.Key) > 1000000 {
6101 return xerrors.Errorf("Value in field t.Key was too long")
6102 }
6103
6104 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
6105 return err
6106 }
6107 if _, err := cw.WriteString(string(t.Key)); err != nil {
6108 return err
6109 }
6110
6111 // t.Name (string) (string)
6112 if len("name") > 1000000 {
6113 return xerrors.Errorf("Value in field \"name\" was too long")
6114 }
6115
6116 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
6117 return err
6118 }
6119 if _, err := cw.WriteString(string("name")); err != nil {
6120 return err
6121 }
6122
6123 if len(t.Name) > 1000000 {
6124 return xerrors.Errorf("Value in field t.Name was too long")
6125 }
6126
6127 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
6128 return err
6129 }
6130 if _, err := cw.WriteString(string(t.Name)); err != nil {
6131 return err
6132 }
6133
6134 // t.LexiconTypeID (string) (string)
6135 if len("$type") > 1000000 {
6136 return xerrors.Errorf("Value in field \"$type\" was too long")
6137 }
6138
6139 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6140 return err
6141 }
6142 if _, err := cw.WriteString(string("$type")); err != nil {
6143 return err
6144 }
6145
6146 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil {
6147 return err
6148 }
6149 if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil {
6150 return err
6151 }
6152
6153 // t.CreatedAt (string) (string)
6154 if len("createdAt") > 1000000 {
6155 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6156 }
6157
6158 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6159 return err
6160 }
6161 if _, err := cw.WriteString(string("createdAt")); err != nil {
6162 return err
6163 }
6164
6165 if len(t.CreatedAt) > 1000000 {
6166 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6167 }
6168
6169 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6170 return err
6171 }
6172 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6173 return err
6174 }
6175 return nil
6176}
6177
6178func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) {
6179 *t = PublicKey{}
6180
6181 cr := cbg.NewCborReader(r)
6182
6183 maj, extra, err := cr.ReadHeader()
6184 if err != nil {
6185 return err
6186 }
6187 defer func() {
6188 if err == io.EOF {
6189 err = io.ErrUnexpectedEOF
6190 }
6191 }()
6192
6193 if maj != cbg.MajMap {
6194 return fmt.Errorf("cbor input should be of type map")
6195 }
6196
6197 if extra > cbg.MaxLength {
6198 return fmt.Errorf("PublicKey: map struct too large (%d)", extra)
6199 }
6200
6201 n := extra
6202
6203 nameBuf := make([]byte, 9)
6204 for i := uint64(0); i < n; i++ {
6205 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6206 if err != nil {
6207 return err
6208 }
6209
6210 if !ok {
6211 // Field doesn't exist on this type, so ignore it
6212 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6213 return err
6214 }
6215 continue
6216 }
6217
6218 switch string(nameBuf[:nameLen]) {
6219 // t.Key (string) (string)
6220 case "key":
6221
6222 {
6223 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6224 if err != nil {
6225 return err
6226 }
6227
6228 t.Key = string(sval)
6229 }
6230 // t.Name (string) (string)
6231 case "name":
6232
6233 {
6234 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6235 if err != nil {
6236 return err
6237 }
6238
6239 t.Name = string(sval)
6240 }
6241 // t.LexiconTypeID (string) (string)
6242 case "$type":
6243
6244 {
6245 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6246 if err != nil {
6247 return err
6248 }
6249
6250 t.LexiconTypeID = string(sval)
6251 }
6252 // t.CreatedAt (string) (string)
6253 case "createdAt":
6254
6255 {
6256 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6257 if err != nil {
6258 return err
6259 }
6260
6261 t.CreatedAt = string(sval)
6262 }
6263
6264 default:
6265 // Field doesn't exist on this type, so ignore it
6266 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6267 return err
6268 }
6269 }
6270 }
6271
6272 return nil
6273}
6274func (t *Repo) MarshalCBOR(w io.Writer) error {
6275 if t == nil {
6276 _, err := w.Write(cbg.CborNull)
6277 return err
6278 }
6279
6280 cw := cbg.NewCborWriter(w)
6281 fieldCount := 10
6282
6283 if t.Description == nil {
6284 fieldCount--
6285 }
6286
6287 if t.Labels == nil {
6288 fieldCount--
6289 }
6290
6291 if t.Source == nil {
6292 fieldCount--
6293 }
6294
6295 if t.Spindle == nil {
6296 fieldCount--
6297 }
6298
6299 if t.Topics == nil {
6300 fieldCount--
6301 }
6302
6303 if t.Website == nil {
6304 fieldCount--
6305 }
6306
6307 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6308 return err
6309 }
6310
6311 // t.Knot (string) (string)
6312 if len("knot") > 1000000 {
6313 return xerrors.Errorf("Value in field \"knot\" was too long")
6314 }
6315
6316 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
6317 return err
6318 }
6319 if _, err := cw.WriteString(string("knot")); err != nil {
6320 return err
6321 }
6322
6323 if len(t.Knot) > 1000000 {
6324 return xerrors.Errorf("Value in field t.Knot was too long")
6325 }
6326
6327 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
6328 return err
6329 }
6330 if _, err := cw.WriteString(string(t.Knot)); err != nil {
6331 return err
6332 }
6333
6334 // t.Name (string) (string)
6335 if len("name") > 1000000 {
6336 return xerrors.Errorf("Value in field \"name\" was too long")
6337 }
6338
6339 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
6340 return err
6341 }
6342 if _, err := cw.WriteString(string("name")); err != nil {
6343 return err
6344 }
6345
6346 if len(t.Name) > 1000000 {
6347 return xerrors.Errorf("Value in field t.Name was too long")
6348 }
6349
6350 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
6351 return err
6352 }
6353 if _, err := cw.WriteString(string(t.Name)); err != nil {
6354 return err
6355 }
6356
6357 // t.LexiconTypeID (string) (string)
6358 if len("$type") > 1000000 {
6359 return xerrors.Errorf("Value in field \"$type\" was too long")
6360 }
6361
6362 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6363 return err
6364 }
6365 if _, err := cw.WriteString(string("$type")); err != nil {
6366 return err
6367 }
6368
6369 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil {
6370 return err
6371 }
6372 if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil {
6373 return err
6374 }
6375
6376 // t.Labels ([]string) (slice)
6377 if t.Labels != nil {
6378
6379 if len("labels") > 1000000 {
6380 return xerrors.Errorf("Value in field \"labels\" was too long")
6381 }
6382
6383 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("labels"))); err != nil {
6384 return err
6385 }
6386 if _, err := cw.WriteString(string("labels")); err != nil {
6387 return err
6388 }
6389
6390 if len(t.Labels) > 8192 {
6391 return xerrors.Errorf("Slice value in field t.Labels was too long")
6392 }
6393
6394 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Labels))); err != nil {
6395 return err
6396 }
6397 for _, v := range t.Labels {
6398 if len(v) > 1000000 {
6399 return xerrors.Errorf("Value in field v was too long")
6400 }
6401
6402 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
6403 return err
6404 }
6405 if _, err := cw.WriteString(string(v)); err != nil {
6406 return err
6407 }
6408
6409 }
6410 }
6411
6412 // t.Source (string) (string)
6413 if t.Source != nil {
6414
6415 if len("source") > 1000000 {
6416 return xerrors.Errorf("Value in field \"source\" was too long")
6417 }
6418
6419 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
6420 return err
6421 }
6422 if _, err := cw.WriteString(string("source")); err != nil {
6423 return err
6424 }
6425
6426 if t.Source == nil {
6427 if _, err := cw.Write(cbg.CborNull); err != nil {
6428 return err
6429 }
6430 } else {
6431 if len(*t.Source) > 1000000 {
6432 return xerrors.Errorf("Value in field t.Source was too long")
6433 }
6434
6435 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil {
6436 return err
6437 }
6438 if _, err := cw.WriteString(string(*t.Source)); err != nil {
6439 return err
6440 }
6441 }
6442 }
6443
6444 // t.Topics ([]string) (slice)
6445 if t.Topics != nil {
6446
6447 if len("topics") > 1000000 {
6448 return xerrors.Errorf("Value in field \"topics\" was too long")
6449 }
6450
6451 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("topics"))); err != nil {
6452 return err
6453 }
6454 if _, err := cw.WriteString(string("topics")); err != nil {
6455 return err
6456 }
6457
6458 if len(t.Topics) > 8192 {
6459 return xerrors.Errorf("Slice value in field t.Topics was too long")
6460 }
6461
6462 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Topics))); err != nil {
6463 return err
6464 }
6465 for _, v := range t.Topics {
6466 if len(v) > 1000000 {
6467 return xerrors.Errorf("Value in field v was too long")
6468 }
6469
6470 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
6471 return err
6472 }
6473 if _, err := cw.WriteString(string(v)); err != nil {
6474 return err
6475 }
6476
6477 }
6478 }
6479
6480 // t.Spindle (string) (string)
6481 if t.Spindle != nil {
6482
6483 if len("spindle") > 1000000 {
6484 return xerrors.Errorf("Value in field \"spindle\" was too long")
6485 }
6486
6487 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("spindle"))); err != nil {
6488 return err
6489 }
6490 if _, err := cw.WriteString(string("spindle")); err != nil {
6491 return err
6492 }
6493
6494 if t.Spindle == nil {
6495 if _, err := cw.Write(cbg.CborNull); err != nil {
6496 return err
6497 }
6498 } else {
6499 if len(*t.Spindle) > 1000000 {
6500 return xerrors.Errorf("Value in field t.Spindle was too long")
6501 }
6502
6503 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Spindle))); err != nil {
6504 return err
6505 }
6506 if _, err := cw.WriteString(string(*t.Spindle)); err != nil {
6507 return err
6508 }
6509 }
6510 }
6511
6512 // t.Website (string) (string)
6513 if t.Website != nil {
6514
6515 if len("website") > 1000000 {
6516 return xerrors.Errorf("Value in field \"website\" was too long")
6517 }
6518
6519 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("website"))); err != nil {
6520 return err
6521 }
6522 if _, err := cw.WriteString(string("website")); err != nil {
6523 return err
6524 }
6525
6526 if t.Website == nil {
6527 if _, err := cw.Write(cbg.CborNull); err != nil {
6528 return err
6529 }
6530 } else {
6531 if len(*t.Website) > 1000000 {
6532 return xerrors.Errorf("Value in field t.Website was too long")
6533 }
6534
6535 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Website))); err != nil {
6536 return err
6537 }
6538 if _, err := cw.WriteString(string(*t.Website)); err != nil {
6539 return err
6540 }
6541 }
6542 }
6543
6544 // t.CreatedAt (string) (string)
6545 if len("createdAt") > 1000000 {
6546 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6547 }
6548
6549 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6550 return err
6551 }
6552 if _, err := cw.WriteString(string("createdAt")); err != nil {
6553 return err
6554 }
6555
6556 if len(t.CreatedAt) > 1000000 {
6557 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6558 }
6559
6560 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6561 return err
6562 }
6563 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6564 return err
6565 }
6566
6567 // t.Description (string) (string)
6568 if t.Description != nil {
6569
6570 if len("description") > 1000000 {
6571 return xerrors.Errorf("Value in field \"description\" was too long")
6572 }
6573
6574 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
6575 return err
6576 }
6577 if _, err := cw.WriteString(string("description")); err != nil {
6578 return err
6579 }
6580
6581 if t.Description == nil {
6582 if _, err := cw.Write(cbg.CborNull); err != nil {
6583 return err
6584 }
6585 } else {
6586 if len(*t.Description) > 1000000 {
6587 return xerrors.Errorf("Value in field t.Description was too long")
6588 }
6589
6590 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
6591 return err
6592 }
6593 if _, err := cw.WriteString(string(*t.Description)); err != nil {
6594 return err
6595 }
6596 }
6597 }
6598 return nil
6599}
6600
6601func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) {
6602 *t = Repo{}
6603
6604 cr := cbg.NewCborReader(r)
6605
6606 maj, extra, err := cr.ReadHeader()
6607 if err != nil {
6608 return err
6609 }
6610 defer func() {
6611 if err == io.EOF {
6612 err = io.ErrUnexpectedEOF
6613 }
6614 }()
6615
6616 if maj != cbg.MajMap {
6617 return fmt.Errorf("cbor input should be of type map")
6618 }
6619
6620 if extra > cbg.MaxLength {
6621 return fmt.Errorf("Repo: map struct too large (%d)", extra)
6622 }
6623
6624 n := extra
6625
6626 nameBuf := make([]byte, 11)
6627 for i := uint64(0); i < n; i++ {
6628 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6629 if err != nil {
6630 return err
6631 }
6632
6633 if !ok {
6634 // Field doesn't exist on this type, so ignore it
6635 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6636 return err
6637 }
6638 continue
6639 }
6640
6641 switch string(nameBuf[:nameLen]) {
6642 // t.Knot (string) (string)
6643 case "knot":
6644
6645 {
6646 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6647 if err != nil {
6648 return err
6649 }
6650
6651 t.Knot = string(sval)
6652 }
6653 // t.Name (string) (string)
6654 case "name":
6655
6656 {
6657 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6658 if err != nil {
6659 return err
6660 }
6661
6662 t.Name = string(sval)
6663 }
6664 // t.LexiconTypeID (string) (string)
6665 case "$type":
6666
6667 {
6668 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6669 if err != nil {
6670 return err
6671 }
6672
6673 t.LexiconTypeID = string(sval)
6674 }
6675 // t.Labels ([]string) (slice)
6676 case "labels":
6677
6678 maj, extra, err = cr.ReadHeader()
6679 if err != nil {
6680 return err
6681 }
6682
6683 if extra > 8192 {
6684 return fmt.Errorf("t.Labels: array too large (%d)", extra)
6685 }
6686
6687 if maj != cbg.MajArray {
6688 return fmt.Errorf("expected cbor array")
6689 }
6690
6691 if extra > 0 {
6692 t.Labels = make([]string, extra)
6693 }
6694
6695 for i := 0; i < int(extra); i++ {
6696 {
6697 var maj byte
6698 var extra uint64
6699 var err error
6700 _ = maj
6701 _ = extra
6702 _ = err
6703
6704 {
6705 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6706 if err != nil {
6707 return err
6708 }
6709
6710 t.Labels[i] = string(sval)
6711 }
6712
6713 }
6714 }
6715 // t.Source (string) (string)
6716 case "source":
6717
6718 {
6719 b, err := cr.ReadByte()
6720 if err != nil {
6721 return err
6722 }
6723 if b != cbg.CborNull[0] {
6724 if err := cr.UnreadByte(); err != nil {
6725 return err
6726 }
6727
6728 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6729 if err != nil {
6730 return err
6731 }
6732
6733 t.Source = (*string)(&sval)
6734 }
6735 }
6736 // t.Topics ([]string) (slice)
6737 case "topics":
6738
6739 maj, extra, err = cr.ReadHeader()
6740 if err != nil {
6741 return err
6742 }
6743
6744 if extra > 8192 {
6745 return fmt.Errorf("t.Topics: array too large (%d)", extra)
6746 }
6747
6748 if maj != cbg.MajArray {
6749 return fmt.Errorf("expected cbor array")
6750 }
6751
6752 if extra > 0 {
6753 t.Topics = make([]string, extra)
6754 }
6755
6756 for i := 0; i < int(extra); i++ {
6757 {
6758 var maj byte
6759 var extra uint64
6760 var err error
6761 _ = maj
6762 _ = extra
6763 _ = err
6764
6765 {
6766 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6767 if err != nil {
6768 return err
6769 }
6770
6771 t.Topics[i] = string(sval)
6772 }
6773
6774 }
6775 }
6776 // t.Spindle (string) (string)
6777 case "spindle":
6778
6779 {
6780 b, err := cr.ReadByte()
6781 if err != nil {
6782 return err
6783 }
6784 if b != cbg.CborNull[0] {
6785 if err := cr.UnreadByte(); err != nil {
6786 return err
6787 }
6788
6789 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6790 if err != nil {
6791 return err
6792 }
6793
6794 t.Spindle = (*string)(&sval)
6795 }
6796 }
6797 // t.Website (string) (string)
6798 case "website":
6799
6800 {
6801 b, err := cr.ReadByte()
6802 if err != nil {
6803 return err
6804 }
6805 if b != cbg.CborNull[0] {
6806 if err := cr.UnreadByte(); err != nil {
6807 return err
6808 }
6809
6810 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6811 if err != nil {
6812 return err
6813 }
6814
6815 t.Website = (*string)(&sval)
6816 }
6817 }
6818 // t.CreatedAt (string) (string)
6819 case "createdAt":
6820
6821 {
6822 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6823 if err != nil {
6824 return err
6825 }
6826
6827 t.CreatedAt = string(sval)
6828 }
6829 // t.Description (string) (string)
6830 case "description":
6831
6832 {
6833 b, err := cr.ReadByte()
6834 if err != nil {
6835 return err
6836 }
6837 if b != cbg.CborNull[0] {
6838 if err := cr.UnreadByte(); err != nil {
6839 return err
6840 }
6841
6842 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6843 if err != nil {
6844 return err
6845 }
6846
6847 t.Description = (*string)(&sval)
6848 }
6849 }
6850
6851 default:
6852 // Field doesn't exist on this type, so ignore it
6853 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6854 return err
6855 }
6856 }
6857 }
6858
6859 return nil
6860}
6861func (t *RepoArtifact) MarshalCBOR(w io.Writer) error {
6862 if t == nil {
6863 _, err := w.Write(cbg.CborNull)
6864 return err
6865 }
6866
6867 cw := cbg.NewCborWriter(w)
6868 fieldCount := 6
6869
6870 if t.Tag == nil {
6871 fieldCount--
6872 }
6873
6874 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6875 return err
6876 }
6877
6878 // t.Tag (util.LexBytes) (slice)
6879 if t.Tag != nil {
6880
6881 if len("tag") > 1000000 {
6882 return xerrors.Errorf("Value in field \"tag\" was too long")
6883 }
6884
6885 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tag"))); err != nil {
6886 return err
6887 }
6888 if _, err := cw.WriteString(string("tag")); err != nil {
6889 return err
6890 }
6891
6892 if len(t.Tag) > 2097152 {
6893 return xerrors.Errorf("Byte array in field t.Tag was too long")
6894 }
6895
6896 if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Tag))); err != nil {
6897 return err
6898 }
6899
6900 if _, err := cw.Write(t.Tag); err != nil {
6901 return err
6902 }
6903
6904 }
6905
6906 // t.Name (string) (string)
6907 if len("name") > 1000000 {
6908 return xerrors.Errorf("Value in field \"name\" was too long")
6909 }
6910
6911 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
6912 return err
6913 }
6914 if _, err := cw.WriteString(string("name")); err != nil {
6915 return err
6916 }
6917
6918 if len(t.Name) > 1000000 {
6919 return xerrors.Errorf("Value in field t.Name was too long")
6920 }
6921
6922 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
6923 return err
6924 }
6925 if _, err := cw.WriteString(string(t.Name)); err != nil {
6926 return err
6927 }
6928
6929 // t.Repo (string) (string)
6930 if len("repo") > 1000000 {
6931 return xerrors.Errorf("Value in field \"repo\" was too long")
6932 }
6933
6934 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6935 return err
6936 }
6937 if _, err := cw.WriteString(string("repo")); err != nil {
6938 return err
6939 }
6940
6941 if len(t.Repo) > 1000000 {
6942 return xerrors.Errorf("Value in field t.Repo was too long")
6943 }
6944
6945 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
6946 return err
6947 }
6948 if _, err := cw.WriteString(string(t.Repo)); err != nil {
6949 return err
6950 }
6951
6952 // t.LexiconTypeID (string) (string)
6953 if len("$type") > 1000000 {
6954 return xerrors.Errorf("Value in field \"$type\" was too long")
6955 }
6956
6957 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6958 return err
6959 }
6960 if _, err := cw.WriteString(string("$type")); err != nil {
6961 return err
6962 }
6963
6964 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.artifact"))); err != nil {
6965 return err
6966 }
6967 if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil {
6968 return err
6969 }
6970
6971 // t.Artifact (util.LexBlob) (struct)
6972 if len("artifact") > 1000000 {
6973 return xerrors.Errorf("Value in field \"artifact\" was too long")
6974 }
6975
6976 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("artifact"))); err != nil {
6977 return err
6978 }
6979 if _, err := cw.WriteString(string("artifact")); err != nil {
6980 return err
6981 }
6982
6983 if err := t.Artifact.MarshalCBOR(cw); err != nil {
6984 return err
6985 }
6986
6987 // t.CreatedAt (string) (string)
6988 if len("createdAt") > 1000000 {
6989 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6990 }
6991
6992 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6993 return err
6994 }
6995 if _, err := cw.WriteString(string("createdAt")); err != nil {
6996 return err
6997 }
6998
6999 if len(t.CreatedAt) > 1000000 {
7000 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7001 }
7002
7003 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7004 return err
7005 }
7006 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7007 return err
7008 }
7009 return nil
7010}
7011
7012func (t *RepoArtifact) UnmarshalCBOR(r io.Reader) (err error) {
7013 *t = RepoArtifact{}
7014
7015 cr := cbg.NewCborReader(r)
7016
7017 maj, extra, err := cr.ReadHeader()
7018 if err != nil {
7019 return err
7020 }
7021 defer func() {
7022 if err == io.EOF {
7023 err = io.ErrUnexpectedEOF
7024 }
7025 }()
7026
7027 if maj != cbg.MajMap {
7028 return fmt.Errorf("cbor input should be of type map")
7029 }
7030
7031 if extra > cbg.MaxLength {
7032 return fmt.Errorf("RepoArtifact: map struct too large (%d)", extra)
7033 }
7034
7035 n := extra
7036
7037 nameBuf := make([]byte, 9)
7038 for i := uint64(0); i < n; i++ {
7039 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7040 if err != nil {
7041 return err
7042 }
7043
7044 if !ok {
7045 // Field doesn't exist on this type, so ignore it
7046 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7047 return err
7048 }
7049 continue
7050 }
7051
7052 switch string(nameBuf[:nameLen]) {
7053 // t.Tag (util.LexBytes) (slice)
7054 case "tag":
7055
7056 maj, extra, err = cr.ReadHeader()
7057 if err != nil {
7058 return err
7059 }
7060
7061 if extra > 2097152 {
7062 return fmt.Errorf("t.Tag: byte array too large (%d)", extra)
7063 }
7064 if maj != cbg.MajByteString {
7065 return fmt.Errorf("expected byte array")
7066 }
7067
7068 if extra > 0 {
7069 t.Tag = make([]uint8, extra)
7070 }
7071
7072 if _, err := io.ReadFull(cr, t.Tag); err != nil {
7073 return err
7074 }
7075
7076 // t.Name (string) (string)
7077 case "name":
7078
7079 {
7080 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7081 if err != nil {
7082 return err
7083 }
7084
7085 t.Name = string(sval)
7086 }
7087 // t.Repo (string) (string)
7088 case "repo":
7089
7090 {
7091 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7092 if err != nil {
7093 return err
7094 }
7095
7096 t.Repo = string(sval)
7097 }
7098 // t.LexiconTypeID (string) (string)
7099 case "$type":
7100
7101 {
7102 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7103 if err != nil {
7104 return err
7105 }
7106
7107 t.LexiconTypeID = string(sval)
7108 }
7109 // t.Artifact (util.LexBlob) (struct)
7110 case "artifact":
7111
7112 {
7113
7114 b, err := cr.ReadByte()
7115 if err != nil {
7116 return err
7117 }
7118 if b != cbg.CborNull[0] {
7119 if err := cr.UnreadByte(); err != nil {
7120 return err
7121 }
7122 t.Artifact = new(util.LexBlob)
7123 if err := t.Artifact.UnmarshalCBOR(cr); err != nil {
7124 return xerrors.Errorf("unmarshaling t.Artifact pointer: %w", err)
7125 }
7126 }
7127
7128 }
7129 // t.CreatedAt (string) (string)
7130 case "createdAt":
7131
7132 {
7133 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7134 if err != nil {
7135 return err
7136 }
7137
7138 t.CreatedAt = string(sval)
7139 }
7140
7141 default:
7142 // Field doesn't exist on this type, so ignore it
7143 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7144 return err
7145 }
7146 }
7147 }
7148
7149 return nil
7150}
7151func (t *RepoCollaborator) MarshalCBOR(w io.Writer) error {
7152 if t == nil {
7153 _, err := w.Write(cbg.CborNull)
7154 return err
7155 }
7156
7157 cw := cbg.NewCborWriter(w)
7158
7159 if _, err := cw.Write([]byte{164}); err != nil {
7160 return err
7161 }
7162
7163 // t.Repo (string) (string)
7164 if len("repo") > 1000000 {
7165 return xerrors.Errorf("Value in field \"repo\" was too long")
7166 }
7167
7168 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
7169 return err
7170 }
7171 if _, err := cw.WriteString(string("repo")); err != nil {
7172 return err
7173 }
7174
7175 if len(t.Repo) > 1000000 {
7176 return xerrors.Errorf("Value in field t.Repo was too long")
7177 }
7178
7179 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
7180 return err
7181 }
7182 if _, err := cw.WriteString(string(t.Repo)); err != nil {
7183 return err
7184 }
7185
7186 // t.LexiconTypeID (string) (string)
7187 if len("$type") > 1000000 {
7188 return xerrors.Errorf("Value in field \"$type\" was too long")
7189 }
7190
7191 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7192 return err
7193 }
7194 if _, err := cw.WriteString(string("$type")); err != nil {
7195 return err
7196 }
7197
7198 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.collaborator"))); err != nil {
7199 return err
7200 }
7201 if _, err := cw.WriteString(string("sh.tangled.repo.collaborator")); err != nil {
7202 return err
7203 }
7204
7205 // t.Subject (string) (string)
7206 if len("subject") > 1000000 {
7207 return xerrors.Errorf("Value in field \"subject\" was too long")
7208 }
7209
7210 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
7211 return err
7212 }
7213 if _, err := cw.WriteString(string("subject")); err != nil {
7214 return err
7215 }
7216
7217 if len(t.Subject) > 1000000 {
7218 return xerrors.Errorf("Value in field t.Subject was too long")
7219 }
7220
7221 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
7222 return err
7223 }
7224 if _, err := cw.WriteString(string(t.Subject)); err != nil {
7225 return err
7226 }
7227
7228 // t.CreatedAt (string) (string)
7229 if len("createdAt") > 1000000 {
7230 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7231 }
7232
7233 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7234 return err
7235 }
7236 if _, err := cw.WriteString(string("createdAt")); err != nil {
7237 return err
7238 }
7239
7240 if len(t.CreatedAt) > 1000000 {
7241 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7242 }
7243
7244 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7245 return err
7246 }
7247 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7248 return err
7249 }
7250 return nil
7251}
7252
7253func (t *RepoCollaborator) UnmarshalCBOR(r io.Reader) (err error) {
7254 *t = RepoCollaborator{}
7255
7256 cr := cbg.NewCborReader(r)
7257
7258 maj, extra, err := cr.ReadHeader()
7259 if err != nil {
7260 return err
7261 }
7262 defer func() {
7263 if err == io.EOF {
7264 err = io.ErrUnexpectedEOF
7265 }
7266 }()
7267
7268 if maj != cbg.MajMap {
7269 return fmt.Errorf("cbor input should be of type map")
7270 }
7271
7272 if extra > cbg.MaxLength {
7273 return fmt.Errorf("RepoCollaborator: map struct too large (%d)", extra)
7274 }
7275
7276 n := extra
7277
7278 nameBuf := make([]byte, 9)
7279 for i := uint64(0); i < n; i++ {
7280 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7281 if err != nil {
7282 return err
7283 }
7284
7285 if !ok {
7286 // Field doesn't exist on this type, so ignore it
7287 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7288 return err
7289 }
7290 continue
7291 }
7292
7293 switch string(nameBuf[:nameLen]) {
7294 // t.Repo (string) (string)
7295 case "repo":
7296
7297 {
7298 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7299 if err != nil {
7300 return err
7301 }
7302
7303 t.Repo = string(sval)
7304 }
7305 // t.LexiconTypeID (string) (string)
7306 case "$type":
7307
7308 {
7309 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7310 if err != nil {
7311 return err
7312 }
7313
7314 t.LexiconTypeID = string(sval)
7315 }
7316 // t.Subject (string) (string)
7317 case "subject":
7318
7319 {
7320 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7321 if err != nil {
7322 return err
7323 }
7324
7325 t.Subject = string(sval)
7326 }
7327 // t.CreatedAt (string) (string)
7328 case "createdAt":
7329
7330 {
7331 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7332 if err != nil {
7333 return err
7334 }
7335
7336 t.CreatedAt = string(sval)
7337 }
7338
7339 default:
7340 // Field doesn't exist on this type, so ignore it
7341 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7342 return err
7343 }
7344 }
7345 }
7346
7347 return nil
7348}
7349func (t *RepoDiscussion) MarshalCBOR(w io.Writer) error {
7350 if t == nil {
7351 _, err := w.Write(cbg.CborNull)
7352 return err
7353 }
7354
7355 cw := cbg.NewCborWriter(w)
7356 fieldCount := 8
7357
7358 if t.Body == nil {
7359 fieldCount--
7360 }
7361
7362 if t.Mentions == nil {
7363 fieldCount--
7364 }
7365
7366 if t.References == nil {
7367 fieldCount--
7368 }
7369
7370 if t.TargetChannel == nil {
7371 fieldCount--
7372 }
7373
7374 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7375 return err
7376 }
7377
7378 // t.Body (string) (string)
7379 if t.Body != nil {
7380
7381 if len("body") > 1000000 {
7382 return xerrors.Errorf("Value in field \"body\" was too long")
7383 }
7384
7385 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
7386 return err
7387 }
7388 if _, err := cw.WriteString(string("body")); err != nil {
7389 return err
7390 }
7391
7392 if t.Body == nil {
7393 if _, err := cw.Write(cbg.CborNull); err != nil {
7394 return err
7395 }
7396 } else {
7397 if len(*t.Body) > 1000000 {
7398 return xerrors.Errorf("Value in field t.Body was too long")
7399 }
7400
7401 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
7402 return err
7403 }
7404 if _, err := cw.WriteString(string(*t.Body)); err != nil {
7405 return err
7406 }
7407 }
7408 }
7409
7410 // t.Repo (string) (string)
7411 if len("repo") > 1000000 {
7412 return xerrors.Errorf("Value in field \"repo\" was too long")
7413 }
7414
7415 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
7416 return err
7417 }
7418 if _, err := cw.WriteString(string("repo")); err != nil {
7419 return err
7420 }
7421
7422 if len(t.Repo) > 1000000 {
7423 return xerrors.Errorf("Value in field t.Repo was too long")
7424 }
7425
7426 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
7427 return err
7428 }
7429 if _, err := cw.WriteString(string(t.Repo)); err != nil {
7430 return err
7431 }
7432
7433 // t.LexiconTypeID (string) (string)
7434 if len("$type") > 1000000 {
7435 return xerrors.Errorf("Value in field \"$type\" was too long")
7436 }
7437
7438 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7439 return err
7440 }
7441 if _, err := cw.WriteString(string("$type")); err != nil {
7442 return err
7443 }
7444
7445 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.discussion"))); err != nil {
7446 return err
7447 }
7448 if _, err := cw.WriteString(string("sh.tangled.repo.discussion")); err != nil {
7449 return err
7450 }
7451
7452 // t.Title (string) (string)
7453 if len("title") > 1000000 {
7454 return xerrors.Errorf("Value in field \"title\" was too long")
7455 }
7456
7457 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
7458 return err
7459 }
7460 if _, err := cw.WriteString(string("title")); err != nil {
7461 return err
7462 }
7463
7464 if len(t.Title) > 1000000 {
7465 return xerrors.Errorf("Value in field t.Title was too long")
7466 }
7467
7468 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
7469 return err
7470 }
7471 if _, err := cw.WriteString(string(t.Title)); err != nil {
7472 return err
7473 }
7474
7475 // t.Mentions ([]string) (slice)
7476 if t.Mentions != nil {
7477
7478 if len("mentions") > 1000000 {
7479 return xerrors.Errorf("Value in field \"mentions\" was too long")
7480 }
7481
7482 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
7483 return err
7484 }
7485 if _, err := cw.WriteString(string("mentions")); err != nil {
7486 return err
7487 }
7488
7489 if len(t.Mentions) > 8192 {
7490 return xerrors.Errorf("Slice value in field t.Mentions was too long")
7491 }
7492
7493 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
7494 return err
7495 }
7496 for _, v := range t.Mentions {
7497 if len(v) > 1000000 {
7498 return xerrors.Errorf("Value in field v was too long")
7499 }
7500
7501 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
7502 return err
7503 }
7504 if _, err := cw.WriteString(string(v)); err != nil {
7505 return err
7506 }
7507
7508 }
7509 }
7510
7511 // t.CreatedAt (string) (string)
7512 if len("createdAt") > 1000000 {
7513 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7514 }
7515
7516 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7517 return err
7518 }
7519 if _, err := cw.WriteString(string("createdAt")); err != nil {
7520 return err
7521 }
7522
7523 if len(t.CreatedAt) > 1000000 {
7524 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7525 }
7526
7527 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7528 return err
7529 }
7530 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7531 return err
7532 }
7533
7534 // t.References ([]string) (slice)
7535 if t.References != nil {
7536
7537 if len("references") > 1000000 {
7538 return xerrors.Errorf("Value in field \"references\" was too long")
7539 }
7540
7541 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
7542 return err
7543 }
7544 if _, err := cw.WriteString(string("references")); err != nil {
7545 return err
7546 }
7547
7548 if len(t.References) > 8192 {
7549 return xerrors.Errorf("Slice value in field t.References was too long")
7550 }
7551
7552 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
7553 return err
7554 }
7555 for _, v := range t.References {
7556 if len(v) > 1000000 {
7557 return xerrors.Errorf("Value in field v was too long")
7558 }
7559
7560 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
7561 return err
7562 }
7563 if _, err := cw.WriteString(string(v)); err != nil {
7564 return err
7565 }
7566
7567 }
7568 }
7569
7570 // t.TargetChannel (string) (string)
7571 if t.TargetChannel != nil {
7572
7573 if len("targetChannel") > 1000000 {
7574 return xerrors.Errorf("Value in field \"targetChannel\" was too long")
7575 }
7576
7577 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetChannel"))); err != nil {
7578 return err
7579 }
7580 if _, err := cw.WriteString(string("targetChannel")); err != nil {
7581 return err
7582 }
7583
7584 if t.TargetChannel == nil {
7585 if _, err := cw.Write(cbg.CborNull); err != nil {
7586 return err
7587 }
7588 } else {
7589 if len(*t.TargetChannel) > 1000000 {
7590 return xerrors.Errorf("Value in field t.TargetChannel was too long")
7591 }
7592
7593 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.TargetChannel))); err != nil {
7594 return err
7595 }
7596 if _, err := cw.WriteString(string(*t.TargetChannel)); err != nil {
7597 return err
7598 }
7599 }
7600 }
7601 return nil
7602}
7603
7604func (t *RepoDiscussion) UnmarshalCBOR(r io.Reader) (err error) {
7605 *t = RepoDiscussion{}
7606
7607 cr := cbg.NewCborReader(r)
7608
7609 maj, extra, err := cr.ReadHeader()
7610 if err != nil {
7611 return err
7612 }
7613 defer func() {
7614 if err == io.EOF {
7615 err = io.ErrUnexpectedEOF
7616 }
7617 }()
7618
7619 if maj != cbg.MajMap {
7620 return fmt.Errorf("cbor input should be of type map")
7621 }
7622
7623 if extra > cbg.MaxLength {
7624 return fmt.Errorf("RepoDiscussion: map struct too large (%d)", extra)
7625 }
7626
7627 n := extra
7628
7629 nameBuf := make([]byte, 13)
7630 for i := uint64(0); i < n; i++ {
7631 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7632 if err != nil {
7633 return err
7634 }
7635
7636 if !ok {
7637 // Field doesn't exist on this type, so ignore it
7638 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7639 return err
7640 }
7641 continue
7642 }
7643
7644 switch string(nameBuf[:nameLen]) {
7645 // t.Body (string) (string)
7646 case "body":
7647
7648 {
7649 b, err := cr.ReadByte()
7650 if err != nil {
7651 return err
7652 }
7653 if b != cbg.CborNull[0] {
7654 if err := cr.UnreadByte(); err != nil {
7655 return err
7656 }
7657
7658 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7659 if err != nil {
7660 return err
7661 }
7662
7663 t.Body = (*string)(&sval)
7664 }
7665 }
7666 // t.Repo (string) (string)
7667 case "repo":
7668
7669 {
7670 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7671 if err != nil {
7672 return err
7673 }
7674
7675 t.Repo = string(sval)
7676 }
7677 // t.LexiconTypeID (string) (string)
7678 case "$type":
7679
7680 {
7681 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7682 if err != nil {
7683 return err
7684 }
7685
7686 t.LexiconTypeID = string(sval)
7687 }
7688 // t.Title (string) (string)
7689 case "title":
7690
7691 {
7692 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7693 if err != nil {
7694 return err
7695 }
7696
7697 t.Title = string(sval)
7698 }
7699 // t.Mentions ([]string) (slice)
7700 case "mentions":
7701
7702 maj, extra, err = cr.ReadHeader()
7703 if err != nil {
7704 return err
7705 }
7706
7707 if extra > 8192 {
7708 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
7709 }
7710
7711 if maj != cbg.MajArray {
7712 return fmt.Errorf("expected cbor array")
7713 }
7714
7715 if extra > 0 {
7716 t.Mentions = make([]string, extra)
7717 }
7718
7719 for i := 0; i < int(extra); i++ {
7720 {
7721 var maj byte
7722 var extra uint64
7723 var err error
7724 _ = maj
7725 _ = extra
7726 _ = err
7727
7728 {
7729 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7730 if err != nil {
7731 return err
7732 }
7733
7734 t.Mentions[i] = string(sval)
7735 }
7736
7737 }
7738 }
7739 // t.CreatedAt (string) (string)
7740 case "createdAt":
7741
7742 {
7743 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7744 if err != nil {
7745 return err
7746 }
7747
7748 t.CreatedAt = string(sval)
7749 }
7750 // t.References ([]string) (slice)
7751 case "references":
7752
7753 maj, extra, err = cr.ReadHeader()
7754 if err != nil {
7755 return err
7756 }
7757
7758 if extra > 8192 {
7759 return fmt.Errorf("t.References: array too large (%d)", extra)
7760 }
7761
7762 if maj != cbg.MajArray {
7763 return fmt.Errorf("expected cbor array")
7764 }
7765
7766 if extra > 0 {
7767 t.References = make([]string, extra)
7768 }
7769
7770 for i := 0; i < int(extra); i++ {
7771 {
7772 var maj byte
7773 var extra uint64
7774 var err error
7775 _ = maj
7776 _ = extra
7777 _ = err
7778
7779 {
7780 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7781 if err != nil {
7782 return err
7783 }
7784
7785 t.References[i] = string(sval)
7786 }
7787
7788 }
7789 }
7790 // t.TargetChannel (string) (string)
7791 case "targetChannel":
7792
7793 {
7794 b, err := cr.ReadByte()
7795 if err != nil {
7796 return err
7797 }
7798 if b != cbg.CborNull[0] {
7799 if err := cr.UnreadByte(); err != nil {
7800 return err
7801 }
7802
7803 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7804 if err != nil {
7805 return err
7806 }
7807
7808 t.TargetChannel = (*string)(&sval)
7809 }
7810 }
7811
7812 default:
7813 // Field doesn't exist on this type, so ignore it
7814 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7815 return err
7816 }
7817 }
7818 }
7819
7820 return nil
7821}
7822func (t *RepoDiscussionComment) MarshalCBOR(w io.Writer) error {
7823 if t == nil {
7824 _, err := w.Write(cbg.CborNull)
7825 return err
7826 }
7827
7828 cw := cbg.NewCborWriter(w)
7829 fieldCount := 7
7830
7831 if t.Mentions == nil {
7832 fieldCount--
7833 }
7834
7835 if t.References == nil {
7836 fieldCount--
7837 }
7838
7839 if t.ReplyTo == nil {
7840 fieldCount--
7841 }
7842
7843 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7844 return err
7845 }
7846
7847 // t.Body (string) (string)
7848 if len("body") > 1000000 {
7849 return xerrors.Errorf("Value in field \"body\" was too long")
7850 }
7851
7852 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
7853 return err
7854 }
7855 if _, err := cw.WriteString(string("body")); err != nil {
7856 return err
7857 }
7858
7859 if len(t.Body) > 1000000 {
7860 return xerrors.Errorf("Value in field t.Body was too long")
7861 }
7862
7863 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
7864 return err
7865 }
7866 if _, err := cw.WriteString(string(t.Body)); err != nil {
7867 return err
7868 }
7869
7870 // t.LexiconTypeID (string) (string)
7871 if len("$type") > 1000000 {
7872 return xerrors.Errorf("Value in field \"$type\" was too long")
7873 }
7874
7875 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7876 return err
7877 }
7878 if _, err := cw.WriteString(string("$type")); err != nil {
7879 return err
7880 }
7881
7882 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.discussion.comment"))); err != nil {
7883 return err
7884 }
7885 if _, err := cw.WriteString(string("sh.tangled.repo.discussion.comment")); err != nil {
7886 return err
7887 }
7888
7889 // t.ReplyTo (string) (string)
7890 if t.ReplyTo != nil {
7891
7892 if len("replyTo") > 1000000 {
7893 return xerrors.Errorf("Value in field \"replyTo\" was too long")
7894 }
7895
7896 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("replyTo"))); err != nil {
7897 return err
7898 }
7899 if _, err := cw.WriteString(string("replyTo")); err != nil {
7900 return err
7901 }
7902
7903 if t.ReplyTo == nil {
7904 if _, err := cw.Write(cbg.CborNull); err != nil {
7905 return err
7906 }
7907 } else {
7908 if len(*t.ReplyTo) > 1000000 {
7909 return xerrors.Errorf("Value in field t.ReplyTo was too long")
7910 }
7911
7912 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ReplyTo))); err != nil {
7913 return err
7914 }
7915 if _, err := cw.WriteString(string(*t.ReplyTo)); err != nil {
7916 return err
7917 }
7918 }
7919 }
7920
7921 // t.Mentions ([]string) (slice)
7922 if t.Mentions != nil {
7923
7924 if len("mentions") > 1000000 {
7925 return xerrors.Errorf("Value in field \"mentions\" was too long")
7926 }
7927
7928 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
7929 return err
7930 }
7931 if _, err := cw.WriteString(string("mentions")); err != nil {
7932 return err
7933 }
7934
7935 if len(t.Mentions) > 8192 {
7936 return xerrors.Errorf("Slice value in field t.Mentions was too long")
7937 }
7938
7939 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
7940 return err
7941 }
7942 for _, v := range t.Mentions {
7943 if len(v) > 1000000 {
7944 return xerrors.Errorf("Value in field v was too long")
7945 }
7946
7947 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
7948 return err
7949 }
7950 if _, err := cw.WriteString(string(v)); err != nil {
7951 return err
7952 }
7953
7954 }
7955 }
7956
7957 // t.CreatedAt (string) (string)
7958 if len("createdAt") > 1000000 {
7959 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7960 }
7961
7962 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7963 return err
7964 }
7965 if _, err := cw.WriteString(string("createdAt")); err != nil {
7966 return err
7967 }
7968
7969 if len(t.CreatedAt) > 1000000 {
7970 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7971 }
7972
7973 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7974 return err
7975 }
7976 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7977 return err
7978 }
7979
7980 // t.Discussion (string) (string)
7981 if len("discussion") > 1000000 {
7982 return xerrors.Errorf("Value in field \"discussion\" was too long")
7983 }
7984
7985 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("discussion"))); err != nil {
7986 return err
7987 }
7988 if _, err := cw.WriteString(string("discussion")); err != nil {
7989 return err
7990 }
7991
7992 if len(t.Discussion) > 1000000 {
7993 return xerrors.Errorf("Value in field t.Discussion was too long")
7994 }
7995
7996 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Discussion))); err != nil {
7997 return err
7998 }
7999 if _, err := cw.WriteString(string(t.Discussion)); err != nil {
8000 return err
8001 }
8002
8003 // t.References ([]string) (slice)
8004 if t.References != nil {
8005
8006 if len("references") > 1000000 {
8007 return xerrors.Errorf("Value in field \"references\" was too long")
8008 }
8009
8010 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
8011 return err
8012 }
8013 if _, err := cw.WriteString(string("references")); err != nil {
8014 return err
8015 }
8016
8017 if len(t.References) > 8192 {
8018 return xerrors.Errorf("Slice value in field t.References was too long")
8019 }
8020
8021 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
8022 return err
8023 }
8024 for _, v := range t.References {
8025 if len(v) > 1000000 {
8026 return xerrors.Errorf("Value in field v was too long")
8027 }
8028
8029 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
8030 return err
8031 }
8032 if _, err := cw.WriteString(string(v)); err != nil {
8033 return err
8034 }
8035
8036 }
8037 }
8038 return nil
8039}
8040
8041func (t *RepoDiscussionComment) UnmarshalCBOR(r io.Reader) (err error) {
8042 *t = RepoDiscussionComment{}
8043
8044 cr := cbg.NewCborReader(r)
8045
8046 maj, extra, err := cr.ReadHeader()
8047 if err != nil {
8048 return err
8049 }
8050 defer func() {
8051 if err == io.EOF {
8052 err = io.ErrUnexpectedEOF
8053 }
8054 }()
8055
8056 if maj != cbg.MajMap {
8057 return fmt.Errorf("cbor input should be of type map")
8058 }
8059
8060 if extra > cbg.MaxLength {
8061 return fmt.Errorf("RepoDiscussionComment: map struct too large (%d)", extra)
8062 }
8063
8064 n := extra
8065
8066 nameBuf := make([]byte, 10)
8067 for i := uint64(0); i < n; i++ {
8068 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8069 if err != nil {
8070 return err
8071 }
8072
8073 if !ok {
8074 // Field doesn't exist on this type, so ignore it
8075 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8076 return err
8077 }
8078 continue
8079 }
8080
8081 switch string(nameBuf[:nameLen]) {
8082 // t.Body (string) (string)
8083 case "body":
8084
8085 {
8086 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8087 if err != nil {
8088 return err
8089 }
8090
8091 t.Body = string(sval)
8092 }
8093 // t.LexiconTypeID (string) (string)
8094 case "$type":
8095
8096 {
8097 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8098 if err != nil {
8099 return err
8100 }
8101
8102 t.LexiconTypeID = string(sval)
8103 }
8104 // t.ReplyTo (string) (string)
8105 case "replyTo":
8106
8107 {
8108 b, err := cr.ReadByte()
8109 if err != nil {
8110 return err
8111 }
8112 if b != cbg.CborNull[0] {
8113 if err := cr.UnreadByte(); err != nil {
8114 return err
8115 }
8116
8117 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8118 if err != nil {
8119 return err
8120 }
8121
8122 t.ReplyTo = (*string)(&sval)
8123 }
8124 }
8125 // t.Mentions ([]string) (slice)
8126 case "mentions":
8127
8128 maj, extra, err = cr.ReadHeader()
8129 if err != nil {
8130 return err
8131 }
8132
8133 if extra > 8192 {
8134 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
8135 }
8136
8137 if maj != cbg.MajArray {
8138 return fmt.Errorf("expected cbor array")
8139 }
8140
8141 if extra > 0 {
8142 t.Mentions = make([]string, extra)
8143 }
8144
8145 for i := 0; i < int(extra); i++ {
8146 {
8147 var maj byte
8148 var extra uint64
8149 var err error
8150 _ = maj
8151 _ = extra
8152 _ = err
8153
8154 {
8155 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8156 if err != nil {
8157 return err
8158 }
8159
8160 t.Mentions[i] = string(sval)
8161 }
8162
8163 }
8164 }
8165 // t.CreatedAt (string) (string)
8166 case "createdAt":
8167
8168 {
8169 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8170 if err != nil {
8171 return err
8172 }
8173
8174 t.CreatedAt = string(sval)
8175 }
8176 // t.Discussion (string) (string)
8177 case "discussion":
8178
8179 {
8180 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8181 if err != nil {
8182 return err
8183 }
8184
8185 t.Discussion = string(sval)
8186 }
8187 // t.References ([]string) (slice)
8188 case "references":
8189
8190 maj, extra, err = cr.ReadHeader()
8191 if err != nil {
8192 return err
8193 }
8194
8195 if extra > 8192 {
8196 return fmt.Errorf("t.References: array too large (%d)", extra)
8197 }
8198
8199 if maj != cbg.MajArray {
8200 return fmt.Errorf("expected cbor array")
8201 }
8202
8203 if extra > 0 {
8204 t.References = make([]string, extra)
8205 }
8206
8207 for i := 0; i < int(extra); i++ {
8208 {
8209 var maj byte
8210 var extra uint64
8211 var err error
8212 _ = maj
8213 _ = extra
8214 _ = err
8215
8216 {
8217 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8218 if err != nil {
8219 return err
8220 }
8221
8222 t.References[i] = string(sval)
8223 }
8224
8225 }
8226 }
8227
8228 default:
8229 // Field doesn't exist on this type, so ignore it
8230 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8231 return err
8232 }
8233 }
8234 }
8235
8236 return nil
8237}
8238func (t *RepoDiscussionState) MarshalCBOR(w io.Writer) error {
8239 if t == nil {
8240 _, err := w.Write(cbg.CborNull)
8241 return err
8242 }
8243
8244 cw := cbg.NewCborWriter(w)
8245
8246 if _, err := cw.Write([]byte{164}); err != nil {
8247 return err
8248 }
8249
8250 // t.LexiconTypeID (string) (string)
8251 if len("$type") > 1000000 {
8252 return xerrors.Errorf("Value in field \"$type\" was too long")
8253 }
8254
8255 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8256 return err
8257 }
8258 if _, err := cw.WriteString(string("$type")); err != nil {
8259 return err
8260 }
8261
8262 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.discussion.state"))); err != nil {
8263 return err
8264 }
8265 if _, err := cw.WriteString(string("sh.tangled.repo.discussion.state")); err != nil {
8266 return err
8267 }
8268
8269 // t.State (string) (string)
8270 if len("state") > 1000000 {
8271 return xerrors.Errorf("Value in field \"state\" was too long")
8272 }
8273
8274 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil {
8275 return err
8276 }
8277 if _, err := cw.WriteString(string("state")); err != nil {
8278 return err
8279 }
8280
8281 if len(t.State) > 1000000 {
8282 return xerrors.Errorf("Value in field t.State was too long")
8283 }
8284
8285 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil {
8286 return err
8287 }
8288 if _, err := cw.WriteString(string(t.State)); err != nil {
8289 return err
8290 }
8291
8292 // t.CreatedAt (string) (string)
8293 if len("createdAt") > 1000000 {
8294 return xerrors.Errorf("Value in field \"createdAt\" was too long")
8295 }
8296
8297 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
8298 return err
8299 }
8300 if _, err := cw.WriteString(string("createdAt")); err != nil {
8301 return err
8302 }
8303
8304 if len(t.CreatedAt) > 1000000 {
8305 return xerrors.Errorf("Value in field t.CreatedAt was too long")
8306 }
8307
8308 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
8309 return err
8310 }
8311 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
8312 return err
8313 }
8314
8315 // t.Discussion (string) (string)
8316 if len("discussion") > 1000000 {
8317 return xerrors.Errorf("Value in field \"discussion\" was too long")
8318 }
8319
8320 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("discussion"))); err != nil {
8321 return err
8322 }
8323 if _, err := cw.WriteString(string("discussion")); err != nil {
8324 return err
8325 }
8326
8327 if len(t.Discussion) > 1000000 {
8328 return xerrors.Errorf("Value in field t.Discussion was too long")
8329 }
8330
8331 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Discussion))); err != nil {
8332 return err
8333 }
8334 if _, err := cw.WriteString(string(t.Discussion)); err != nil {
8335 return err
8336 }
8337 return nil
8338}
8339
8340func (t *RepoDiscussionState) UnmarshalCBOR(r io.Reader) (err error) {
8341 *t = RepoDiscussionState{}
8342
8343 cr := cbg.NewCborReader(r)
8344
8345 maj, extra, err := cr.ReadHeader()
8346 if err != nil {
8347 return err
8348 }
8349 defer func() {
8350 if err == io.EOF {
8351 err = io.ErrUnexpectedEOF
8352 }
8353 }()
8354
8355 if maj != cbg.MajMap {
8356 return fmt.Errorf("cbor input should be of type map")
8357 }
8358
8359 if extra > cbg.MaxLength {
8360 return fmt.Errorf("RepoDiscussionState: map struct too large (%d)", extra)
8361 }
8362
8363 n := extra
8364
8365 nameBuf := make([]byte, 10)
8366 for i := uint64(0); i < n; i++ {
8367 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8368 if err != nil {
8369 return err
8370 }
8371
8372 if !ok {
8373 // Field doesn't exist on this type, so ignore it
8374 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8375 return err
8376 }
8377 continue
8378 }
8379
8380 switch string(nameBuf[:nameLen]) {
8381 // t.LexiconTypeID (string) (string)
8382 case "$type":
8383
8384 {
8385 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8386 if err != nil {
8387 return err
8388 }
8389
8390 t.LexiconTypeID = string(sval)
8391 }
8392 // t.State (string) (string)
8393 case "state":
8394
8395 {
8396 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8397 if err != nil {
8398 return err
8399 }
8400
8401 t.State = string(sval)
8402 }
8403 // t.CreatedAt (string) (string)
8404 case "createdAt":
8405
8406 {
8407 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8408 if err != nil {
8409 return err
8410 }
8411
8412 t.CreatedAt = string(sval)
8413 }
8414 // t.Discussion (string) (string)
8415 case "discussion":
8416
8417 {
8418 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8419 if err != nil {
8420 return err
8421 }
8422
8423 t.Discussion = string(sval)
8424 }
8425
8426 default:
8427 // Field doesn't exist on this type, so ignore it
8428 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8429 return err
8430 }
8431 }
8432 }
8433
8434 return nil
8435}
8436func (t *RepoIssue) MarshalCBOR(w io.Writer) error {
8437 if t == nil {
8438 _, err := w.Write(cbg.CborNull)
8439 return err
8440 }
8441
8442 cw := cbg.NewCborWriter(w)
8443 fieldCount := 7
8444
8445 if t.Body == nil {
8446 fieldCount--
8447 }
8448
8449 if t.Mentions == nil {
8450 fieldCount--
8451 }
8452
8453 if t.References == nil {
8454 fieldCount--
8455 }
8456
8457 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
8458 return err
8459 }
8460
8461 // t.Body (string) (string)
8462 if t.Body != nil {
8463
8464 if len("body") > 1000000 {
8465 return xerrors.Errorf("Value in field \"body\" was too long")
8466 }
8467
8468 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
8469 return err
8470 }
8471 if _, err := cw.WriteString(string("body")); err != nil {
8472 return err
8473 }
8474
8475 if t.Body == nil {
8476 if _, err := cw.Write(cbg.CborNull); err != nil {
8477 return err
8478 }
8479 } else {
8480 if len(*t.Body) > 1000000 {
8481 return xerrors.Errorf("Value in field t.Body was too long")
8482 }
8483
8484 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
8485 return err
8486 }
8487 if _, err := cw.WriteString(string(*t.Body)); err != nil {
8488 return err
8489 }
8490 }
8491 }
8492
8493 // t.Repo (string) (string)
8494 if len("repo") > 1000000 {
8495 return xerrors.Errorf("Value in field \"repo\" was too long")
8496 }
8497
8498 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
8499 return err
8500 }
8501 if _, err := cw.WriteString(string("repo")); err != nil {
8502 return err
8503 }
8504
8505 if len(t.Repo) > 1000000 {
8506 return xerrors.Errorf("Value in field t.Repo was too long")
8507 }
8508
8509 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
8510 return err
8511 }
8512 if _, err := cw.WriteString(string(t.Repo)); err != nil {
8513 return err
8514 }
8515
8516 // t.LexiconTypeID (string) (string)
8517 if len("$type") > 1000000 {
8518 return xerrors.Errorf("Value in field \"$type\" was too long")
8519 }
8520
8521 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8522 return err
8523 }
8524 if _, err := cw.WriteString(string("$type")); err != nil {
8525 return err
8526 }
8527
8528 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil {
8529 return err
8530 }
8531 if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil {
8532 return err
8533 }
8534
8535 // t.Title (string) (string)
8536 if len("title") > 1000000 {
8537 return xerrors.Errorf("Value in field \"title\" was too long")
8538 }
8539
8540 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
8541 return err
8542 }
8543 if _, err := cw.WriteString(string("title")); err != nil {
8544 return err
8545 }
8546
8547 if len(t.Title) > 1000000 {
8548 return xerrors.Errorf("Value in field t.Title was too long")
8549 }
8550
8551 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
8552 return err
8553 }
8554 if _, err := cw.WriteString(string(t.Title)); err != nil {
8555 return err
8556 }
8557
8558 // t.Mentions ([]string) (slice)
8559 if t.Mentions != nil {
8560
8561 if len("mentions") > 1000000 {
8562 return xerrors.Errorf("Value in field \"mentions\" was too long")
8563 }
8564
8565 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
8566 return err
8567 }
8568 if _, err := cw.WriteString(string("mentions")); err != nil {
8569 return err
8570 }
8571
8572 if len(t.Mentions) > 8192 {
8573 return xerrors.Errorf("Slice value in field t.Mentions was too long")
8574 }
8575
8576 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
8577 return err
8578 }
8579 for _, v := range t.Mentions {
8580 if len(v) > 1000000 {
8581 return xerrors.Errorf("Value in field v was too long")
8582 }
8583
8584 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
8585 return err
8586 }
8587 if _, err := cw.WriteString(string(v)); err != nil {
8588 return err
8589 }
8590
8591 }
8592 }
8593
8594 // t.CreatedAt (string) (string)
8595 if len("createdAt") > 1000000 {
8596 return xerrors.Errorf("Value in field \"createdAt\" was too long")
8597 }
8598
8599 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
8600 return err
8601 }
8602 if _, err := cw.WriteString(string("createdAt")); err != nil {
8603 return err
8604 }
8605
8606 if len(t.CreatedAt) > 1000000 {
8607 return xerrors.Errorf("Value in field t.CreatedAt was too long")
8608 }
8609
8610 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
8611 return err
8612 }
8613 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
8614 return err
8615 }
8616
8617 // t.References ([]string) (slice)
8618 if t.References != nil {
8619
8620 if len("references") > 1000000 {
8621 return xerrors.Errorf("Value in field \"references\" was too long")
8622 }
8623
8624 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
8625 return err
8626 }
8627 if _, err := cw.WriteString(string("references")); err != nil {
8628 return err
8629 }
8630
8631 if len(t.References) > 8192 {
8632 return xerrors.Errorf("Slice value in field t.References was too long")
8633 }
8634
8635 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
8636 return err
8637 }
8638 for _, v := range t.References {
8639 if len(v) > 1000000 {
8640 return xerrors.Errorf("Value in field v was too long")
8641 }
8642
8643 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
8644 return err
8645 }
8646 if _, err := cw.WriteString(string(v)); err != nil {
8647 return err
8648 }
8649
8650 }
8651 }
8652 return nil
8653}
8654
8655func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) {
8656 *t = RepoIssue{}
8657
8658 cr := cbg.NewCborReader(r)
8659
8660 maj, extra, err := cr.ReadHeader()
8661 if err != nil {
8662 return err
8663 }
8664 defer func() {
8665 if err == io.EOF {
8666 err = io.ErrUnexpectedEOF
8667 }
8668 }()
8669
8670 if maj != cbg.MajMap {
8671 return fmt.Errorf("cbor input should be of type map")
8672 }
8673
8674 if extra > cbg.MaxLength {
8675 return fmt.Errorf("RepoIssue: map struct too large (%d)", extra)
8676 }
8677
8678 n := extra
8679
8680 nameBuf := make([]byte, 10)
8681 for i := uint64(0); i < n; i++ {
8682 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8683 if err != nil {
8684 return err
8685 }
8686
8687 if !ok {
8688 // Field doesn't exist on this type, so ignore it
8689 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8690 return err
8691 }
8692 continue
8693 }
8694
8695 switch string(nameBuf[:nameLen]) {
8696 // t.Body (string) (string)
8697 case "body":
8698
8699 {
8700 b, err := cr.ReadByte()
8701 if err != nil {
8702 return err
8703 }
8704 if b != cbg.CborNull[0] {
8705 if err := cr.UnreadByte(); err != nil {
8706 return err
8707 }
8708
8709 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8710 if err != nil {
8711 return err
8712 }
8713
8714 t.Body = (*string)(&sval)
8715 }
8716 }
8717 // t.Repo (string) (string)
8718 case "repo":
8719
8720 {
8721 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8722 if err != nil {
8723 return err
8724 }
8725
8726 t.Repo = string(sval)
8727 }
8728 // t.LexiconTypeID (string) (string)
8729 case "$type":
8730
8731 {
8732 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8733 if err != nil {
8734 return err
8735 }
8736
8737 t.LexiconTypeID = string(sval)
8738 }
8739 // t.Title (string) (string)
8740 case "title":
8741
8742 {
8743 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8744 if err != nil {
8745 return err
8746 }
8747
8748 t.Title = string(sval)
8749 }
8750 // t.Mentions ([]string) (slice)
8751 case "mentions":
8752
8753 maj, extra, err = cr.ReadHeader()
8754 if err != nil {
8755 return err
8756 }
8757
8758 if extra > 8192 {
8759 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
8760 }
8761
8762 if maj != cbg.MajArray {
8763 return fmt.Errorf("expected cbor array")
8764 }
8765
8766 if extra > 0 {
8767 t.Mentions = make([]string, extra)
8768 }
8769
8770 for i := 0; i < int(extra); i++ {
8771 {
8772 var maj byte
8773 var extra uint64
8774 var err error
8775 _ = maj
8776 _ = extra
8777 _ = err
8778
8779 {
8780 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8781 if err != nil {
8782 return err
8783 }
8784
8785 t.Mentions[i] = string(sval)
8786 }
8787
8788 }
8789 }
8790 // t.CreatedAt (string) (string)
8791 case "createdAt":
8792
8793 {
8794 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8795 if err != nil {
8796 return err
8797 }
8798
8799 t.CreatedAt = string(sval)
8800 }
8801 // t.References ([]string) (slice)
8802 case "references":
8803
8804 maj, extra, err = cr.ReadHeader()
8805 if err != nil {
8806 return err
8807 }
8808
8809 if extra > 8192 {
8810 return fmt.Errorf("t.References: array too large (%d)", extra)
8811 }
8812
8813 if maj != cbg.MajArray {
8814 return fmt.Errorf("expected cbor array")
8815 }
8816
8817 if extra > 0 {
8818 t.References = make([]string, extra)
8819 }
8820
8821 for i := 0; i < int(extra); i++ {
8822 {
8823 var maj byte
8824 var extra uint64
8825 var err error
8826 _ = maj
8827 _ = extra
8828 _ = err
8829
8830 {
8831 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8832 if err != nil {
8833 return err
8834 }
8835
8836 t.References[i] = string(sval)
8837 }
8838
8839 }
8840 }
8841
8842 default:
8843 // Field doesn't exist on this type, so ignore it
8844 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8845 return err
8846 }
8847 }
8848 }
8849
8850 return nil
8851}
8852func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error {
8853 if t == nil {
8854 _, err := w.Write(cbg.CborNull)
8855 return err
8856 }
8857
8858 cw := cbg.NewCborWriter(w)
8859 fieldCount := 7
8860
8861 if t.Mentions == nil {
8862 fieldCount--
8863 }
8864
8865 if t.References == nil {
8866 fieldCount--
8867 }
8868
8869 if t.ReplyTo == nil {
8870 fieldCount--
8871 }
8872
8873 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
8874 return err
8875 }
8876
8877 // t.Body (string) (string)
8878 if len("body") > 1000000 {
8879 return xerrors.Errorf("Value in field \"body\" was too long")
8880 }
8881
8882 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
8883 return err
8884 }
8885 if _, err := cw.WriteString(string("body")); err != nil {
8886 return err
8887 }
8888
8889 if len(t.Body) > 1000000 {
8890 return xerrors.Errorf("Value in field t.Body was too long")
8891 }
8892
8893 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
8894 return err
8895 }
8896 if _, err := cw.WriteString(string(t.Body)); err != nil {
8897 return err
8898 }
8899
8900 // t.LexiconTypeID (string) (string)
8901 if len("$type") > 1000000 {
8902 return xerrors.Errorf("Value in field \"$type\" was too long")
8903 }
8904
8905 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8906 return err
8907 }
8908 if _, err := cw.WriteString(string("$type")); err != nil {
8909 return err
8910 }
8911
8912 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil {
8913 return err
8914 }
8915 if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil {
8916 return err
8917 }
8918
8919 // t.Issue (string) (string)
8920 if len("issue") > 1000000 {
8921 return xerrors.Errorf("Value in field \"issue\" was too long")
8922 }
8923
8924 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
8925 return err
8926 }
8927 if _, err := cw.WriteString(string("issue")); err != nil {
8928 return err
8929 }
8930
8931 if len(t.Issue) > 1000000 {
8932 return xerrors.Errorf("Value in field t.Issue was too long")
8933 }
8934
8935 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
8936 return err
8937 }
8938 if _, err := cw.WriteString(string(t.Issue)); err != nil {
8939 return err
8940 }
8941
8942 // t.ReplyTo (string) (string)
8943 if t.ReplyTo != nil {
8944
8945 if len("replyTo") > 1000000 {
8946 return xerrors.Errorf("Value in field \"replyTo\" was too long")
8947 }
8948
8949 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("replyTo"))); err != nil {
8950 return err
8951 }
8952 if _, err := cw.WriteString(string("replyTo")); err != nil {
8953 return err
8954 }
8955
8956 if t.ReplyTo == nil {
8957 if _, err := cw.Write(cbg.CborNull); err != nil {
8958 return err
8959 }
8960 } else {
8961 if len(*t.ReplyTo) > 1000000 {
8962 return xerrors.Errorf("Value in field t.ReplyTo was too long")
8963 }
8964
8965 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ReplyTo))); err != nil {
8966 return err
8967 }
8968 if _, err := cw.WriteString(string(*t.ReplyTo)); err != nil {
8969 return err
8970 }
8971 }
8972 }
8973
8974 // t.Mentions ([]string) (slice)
8975 if t.Mentions != nil {
8976
8977 if len("mentions") > 1000000 {
8978 return xerrors.Errorf("Value in field \"mentions\" was too long")
8979 }
8980
8981 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
8982 return err
8983 }
8984 if _, err := cw.WriteString(string("mentions")); err != nil {
8985 return err
8986 }
8987
8988 if len(t.Mentions) > 8192 {
8989 return xerrors.Errorf("Slice value in field t.Mentions was too long")
8990 }
8991
8992 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
8993 return err
8994 }
8995 for _, v := range t.Mentions {
8996 if len(v) > 1000000 {
8997 return xerrors.Errorf("Value in field v was too long")
8998 }
8999
9000 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
9001 return err
9002 }
9003 if _, err := cw.WriteString(string(v)); err != nil {
9004 return err
9005 }
9006
9007 }
9008 }
9009
9010 // t.CreatedAt (string) (string)
9011 if len("createdAt") > 1000000 {
9012 return xerrors.Errorf("Value in field \"createdAt\" was too long")
9013 }
9014
9015 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
9016 return err
9017 }
9018 if _, err := cw.WriteString(string("createdAt")); err != nil {
9019 return err
9020 }
9021
9022 if len(t.CreatedAt) > 1000000 {
9023 return xerrors.Errorf("Value in field t.CreatedAt was too long")
9024 }
9025
9026 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
9027 return err
9028 }
9029 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
9030 return err
9031 }
9032
9033 // t.References ([]string) (slice)
9034 if t.References != nil {
9035
9036 if len("references") > 1000000 {
9037 return xerrors.Errorf("Value in field \"references\" was too long")
9038 }
9039
9040 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
9041 return err
9042 }
9043 if _, err := cw.WriteString(string("references")); err != nil {
9044 return err
9045 }
9046
9047 if len(t.References) > 8192 {
9048 return xerrors.Errorf("Slice value in field t.References was too long")
9049 }
9050
9051 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
9052 return err
9053 }
9054 for _, v := range t.References {
9055 if len(v) > 1000000 {
9056 return xerrors.Errorf("Value in field v was too long")
9057 }
9058
9059 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
9060 return err
9061 }
9062 if _, err := cw.WriteString(string(v)); err != nil {
9063 return err
9064 }
9065
9066 }
9067 }
9068 return nil
9069}
9070
9071func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) {
9072 *t = RepoIssueComment{}
9073
9074 cr := cbg.NewCborReader(r)
9075
9076 maj, extra, err := cr.ReadHeader()
9077 if err != nil {
9078 return err
9079 }
9080 defer func() {
9081 if err == io.EOF {
9082 err = io.ErrUnexpectedEOF
9083 }
9084 }()
9085
9086 if maj != cbg.MajMap {
9087 return fmt.Errorf("cbor input should be of type map")
9088 }
9089
9090 if extra > cbg.MaxLength {
9091 return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra)
9092 }
9093
9094 n := extra
9095
9096 nameBuf := make([]byte, 10)
9097 for i := uint64(0); i < n; i++ {
9098 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9099 if err != nil {
9100 return err
9101 }
9102
9103 if !ok {
9104 // Field doesn't exist on this type, so ignore it
9105 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9106 return err
9107 }
9108 continue
9109 }
9110
9111 switch string(nameBuf[:nameLen]) {
9112 // t.Body (string) (string)
9113 case "body":
9114
9115 {
9116 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9117 if err != nil {
9118 return err
9119 }
9120
9121 t.Body = string(sval)
9122 }
9123 // t.LexiconTypeID (string) (string)
9124 case "$type":
9125
9126 {
9127 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9128 if err != nil {
9129 return err
9130 }
9131
9132 t.LexiconTypeID = string(sval)
9133 }
9134 // t.Issue (string) (string)
9135 case "issue":
9136
9137 {
9138 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9139 if err != nil {
9140 return err
9141 }
9142
9143 t.Issue = string(sval)
9144 }
9145 // t.ReplyTo (string) (string)
9146 case "replyTo":
9147
9148 {
9149 b, err := cr.ReadByte()
9150 if err != nil {
9151 return err
9152 }
9153 if b != cbg.CborNull[0] {
9154 if err := cr.UnreadByte(); err != nil {
9155 return err
9156 }
9157
9158 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9159 if err != nil {
9160 return err
9161 }
9162
9163 t.ReplyTo = (*string)(&sval)
9164 }
9165 }
9166 // t.Mentions ([]string) (slice)
9167 case "mentions":
9168
9169 maj, extra, err = cr.ReadHeader()
9170 if err != nil {
9171 return err
9172 }
9173
9174 if extra > 8192 {
9175 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
9176 }
9177
9178 if maj != cbg.MajArray {
9179 return fmt.Errorf("expected cbor array")
9180 }
9181
9182 if extra > 0 {
9183 t.Mentions = make([]string, extra)
9184 }
9185
9186 for i := 0; i < int(extra); i++ {
9187 {
9188 var maj byte
9189 var extra uint64
9190 var err error
9191 _ = maj
9192 _ = extra
9193 _ = err
9194
9195 {
9196 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9197 if err != nil {
9198 return err
9199 }
9200
9201 t.Mentions[i] = string(sval)
9202 }
9203
9204 }
9205 }
9206 // t.CreatedAt (string) (string)
9207 case "createdAt":
9208
9209 {
9210 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9211 if err != nil {
9212 return err
9213 }
9214
9215 t.CreatedAt = string(sval)
9216 }
9217 // t.References ([]string) (slice)
9218 case "references":
9219
9220 maj, extra, err = cr.ReadHeader()
9221 if err != nil {
9222 return err
9223 }
9224
9225 if extra > 8192 {
9226 return fmt.Errorf("t.References: array too large (%d)", extra)
9227 }
9228
9229 if maj != cbg.MajArray {
9230 return fmt.Errorf("expected cbor array")
9231 }
9232
9233 if extra > 0 {
9234 t.References = make([]string, extra)
9235 }
9236
9237 for i := 0; i < int(extra); i++ {
9238 {
9239 var maj byte
9240 var extra uint64
9241 var err error
9242 _ = maj
9243 _ = extra
9244 _ = err
9245
9246 {
9247 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9248 if err != nil {
9249 return err
9250 }
9251
9252 t.References[i] = string(sval)
9253 }
9254
9255 }
9256 }
9257
9258 default:
9259 // Field doesn't exist on this type, so ignore it
9260 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9261 return err
9262 }
9263 }
9264 }
9265
9266 return nil
9267}
9268func (t *RepoIssueState) MarshalCBOR(w io.Writer) error {
9269 if t == nil {
9270 _, err := w.Write(cbg.CborNull)
9271 return err
9272 }
9273
9274 cw := cbg.NewCborWriter(w)
9275
9276 if _, err := cw.Write([]byte{163}); err != nil {
9277 return err
9278 }
9279
9280 // t.LexiconTypeID (string) (string)
9281 if len("$type") > 1000000 {
9282 return xerrors.Errorf("Value in field \"$type\" was too long")
9283 }
9284
9285 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
9286 return err
9287 }
9288 if _, err := cw.WriteString(string("$type")); err != nil {
9289 return err
9290 }
9291
9292 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil {
9293 return err
9294 }
9295 if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil {
9296 return err
9297 }
9298
9299 // t.Issue (string) (string)
9300 if len("issue") > 1000000 {
9301 return xerrors.Errorf("Value in field \"issue\" was too long")
9302 }
9303
9304 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
9305 return err
9306 }
9307 if _, err := cw.WriteString(string("issue")); err != nil {
9308 return err
9309 }
9310
9311 if len(t.Issue) > 1000000 {
9312 return xerrors.Errorf("Value in field t.Issue was too long")
9313 }
9314
9315 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
9316 return err
9317 }
9318 if _, err := cw.WriteString(string(t.Issue)); err != nil {
9319 return err
9320 }
9321
9322 // t.State (string) (string)
9323 if len("state") > 1000000 {
9324 return xerrors.Errorf("Value in field \"state\" was too long")
9325 }
9326
9327 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil {
9328 return err
9329 }
9330 if _, err := cw.WriteString(string("state")); err != nil {
9331 return err
9332 }
9333
9334 if len(t.State) > 1000000 {
9335 return xerrors.Errorf("Value in field t.State was too long")
9336 }
9337
9338 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil {
9339 return err
9340 }
9341 if _, err := cw.WriteString(string(t.State)); err != nil {
9342 return err
9343 }
9344 return nil
9345}
9346
9347func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) {
9348 *t = RepoIssueState{}
9349
9350 cr := cbg.NewCborReader(r)
9351
9352 maj, extra, err := cr.ReadHeader()
9353 if err != nil {
9354 return err
9355 }
9356 defer func() {
9357 if err == io.EOF {
9358 err = io.ErrUnexpectedEOF
9359 }
9360 }()
9361
9362 if maj != cbg.MajMap {
9363 return fmt.Errorf("cbor input should be of type map")
9364 }
9365
9366 if extra > cbg.MaxLength {
9367 return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra)
9368 }
9369
9370 n := extra
9371
9372 nameBuf := make([]byte, 5)
9373 for i := uint64(0); i < n; i++ {
9374 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9375 if err != nil {
9376 return err
9377 }
9378
9379 if !ok {
9380 // Field doesn't exist on this type, so ignore it
9381 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9382 return err
9383 }
9384 continue
9385 }
9386
9387 switch string(nameBuf[:nameLen]) {
9388 // t.LexiconTypeID (string) (string)
9389 case "$type":
9390
9391 {
9392 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9393 if err != nil {
9394 return err
9395 }
9396
9397 t.LexiconTypeID = string(sval)
9398 }
9399 // t.Issue (string) (string)
9400 case "issue":
9401
9402 {
9403 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9404 if err != nil {
9405 return err
9406 }
9407
9408 t.Issue = string(sval)
9409 }
9410 // t.State (string) (string)
9411 case "state":
9412
9413 {
9414 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9415 if err != nil {
9416 return err
9417 }
9418
9419 t.State = string(sval)
9420 }
9421
9422 default:
9423 // Field doesn't exist on this type, so ignore it
9424 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9425 return err
9426 }
9427 }
9428 }
9429
9430 return nil
9431}
9432func (t *RepoPull) MarshalCBOR(w io.Writer) error {
9433 if t == nil {
9434 _, err := w.Write(cbg.CborNull)
9435 return err
9436 }
9437
9438 cw := cbg.NewCborWriter(w)
9439 fieldCount := 10
9440
9441 if t.Body == nil {
9442 fieldCount--
9443 }
9444
9445 if t.Mentions == nil {
9446 fieldCount--
9447 }
9448
9449 if t.Patch == nil {
9450 fieldCount--
9451 }
9452
9453 if t.References == nil {
9454 fieldCount--
9455 }
9456
9457 if t.Source == nil {
9458 fieldCount--
9459 }
9460
9461 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
9462 return err
9463 }
9464
9465 // t.Body (string) (string)
9466 if t.Body != nil {
9467
9468 if len("body") > 1000000 {
9469 return xerrors.Errorf("Value in field \"body\" was too long")
9470 }
9471
9472 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
9473 return err
9474 }
9475 if _, err := cw.WriteString(string("body")); err != nil {
9476 return err
9477 }
9478
9479 if t.Body == nil {
9480 if _, err := cw.Write(cbg.CborNull); err != nil {
9481 return err
9482 }
9483 } else {
9484 if len(*t.Body) > 1000000 {
9485 return xerrors.Errorf("Value in field t.Body was too long")
9486 }
9487
9488 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
9489 return err
9490 }
9491 if _, err := cw.WriteString(string(*t.Body)); err != nil {
9492 return err
9493 }
9494 }
9495 }
9496
9497 // t.LexiconTypeID (string) (string)
9498 if len("$type") > 1000000 {
9499 return xerrors.Errorf("Value in field \"$type\" was too long")
9500 }
9501
9502 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
9503 return err
9504 }
9505 if _, err := cw.WriteString(string("$type")); err != nil {
9506 return err
9507 }
9508
9509 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil {
9510 return err
9511 }
9512 if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil {
9513 return err
9514 }
9515
9516 // t.Patch (string) (string)
9517 if t.Patch != nil {
9518
9519 if len("patch") > 1000000 {
9520 return xerrors.Errorf("Value in field \"patch\" was too long")
9521 }
9522
9523 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil {
9524 return err
9525 }
9526 if _, err := cw.WriteString(string("patch")); err != nil {
9527 return err
9528 }
9529
9530 if t.Patch == nil {
9531 if _, err := cw.Write(cbg.CborNull); err != nil {
9532 return err
9533 }
9534 } else {
9535 if len(*t.Patch) > 1000000 {
9536 return xerrors.Errorf("Value in field t.Patch was too long")
9537 }
9538
9539 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Patch))); err != nil {
9540 return err
9541 }
9542 if _, err := cw.WriteString(string(*t.Patch)); err != nil {
9543 return err
9544 }
9545 }
9546 }
9547
9548 // t.Title (string) (string)
9549 if len("title") > 1000000 {
9550 return xerrors.Errorf("Value in field \"title\" was too long")
9551 }
9552
9553 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
9554 return err
9555 }
9556 if _, err := cw.WriteString(string("title")); err != nil {
9557 return err
9558 }
9559
9560 if len(t.Title) > 1000000 {
9561 return xerrors.Errorf("Value in field t.Title was too long")
9562 }
9563
9564 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
9565 return err
9566 }
9567 if _, err := cw.WriteString(string(t.Title)); err != nil {
9568 return err
9569 }
9570
9571 // t.Source (tangled.RepoPull_Source) (struct)
9572 if t.Source != nil {
9573
9574 if len("source") > 1000000 {
9575 return xerrors.Errorf("Value in field \"source\" was too long")
9576 }
9577
9578 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
9579 return err
9580 }
9581 if _, err := cw.WriteString(string("source")); err != nil {
9582 return err
9583 }
9584
9585 if err := t.Source.MarshalCBOR(cw); err != nil {
9586 return err
9587 }
9588 }
9589
9590 // t.Target (tangled.RepoPull_Target) (struct)
9591 if len("target") > 1000000 {
9592 return xerrors.Errorf("Value in field \"target\" was too long")
9593 }
9594
9595 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("target"))); err != nil {
9596 return err
9597 }
9598 if _, err := cw.WriteString(string("target")); err != nil {
9599 return err
9600 }
9601
9602 if err := t.Target.MarshalCBOR(cw); err != nil {
9603 return err
9604 }
9605
9606 // t.Mentions ([]string) (slice)
9607 if t.Mentions != nil {
9608
9609 if len("mentions") > 1000000 {
9610 return xerrors.Errorf("Value in field \"mentions\" was too long")
9611 }
9612
9613 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
9614 return err
9615 }
9616 if _, err := cw.WriteString(string("mentions")); err != nil {
9617 return err
9618 }
9619
9620 if len(t.Mentions) > 8192 {
9621 return xerrors.Errorf("Slice value in field t.Mentions was too long")
9622 }
9623
9624 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
9625 return err
9626 }
9627 for _, v := range t.Mentions {
9628 if len(v) > 1000000 {
9629 return xerrors.Errorf("Value in field v was too long")
9630 }
9631
9632 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
9633 return err
9634 }
9635 if _, err := cw.WriteString(string(v)); err != nil {
9636 return err
9637 }
9638
9639 }
9640 }
9641
9642 // t.CreatedAt (string) (string)
9643 if len("createdAt") > 1000000 {
9644 return xerrors.Errorf("Value in field \"createdAt\" was too long")
9645 }
9646
9647 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
9648 return err
9649 }
9650 if _, err := cw.WriteString(string("createdAt")); err != nil {
9651 return err
9652 }
9653
9654 if len(t.CreatedAt) > 1000000 {
9655 return xerrors.Errorf("Value in field t.CreatedAt was too long")
9656 }
9657
9658 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
9659 return err
9660 }
9661 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
9662 return err
9663 }
9664
9665 // t.PatchBlob (util.LexBlob) (struct)
9666 if len("patchBlob") > 1000000 {
9667 return xerrors.Errorf("Value in field \"patchBlob\" was too long")
9668 }
9669
9670 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patchBlob"))); err != nil {
9671 return err
9672 }
9673 if _, err := cw.WriteString(string("patchBlob")); err != nil {
9674 return err
9675 }
9676
9677 if err := t.PatchBlob.MarshalCBOR(cw); err != nil {
9678 return err
9679 }
9680
9681 // t.References ([]string) (slice)
9682 if t.References != nil {
9683
9684 if len("references") > 1000000 {
9685 return xerrors.Errorf("Value in field \"references\" was too long")
9686 }
9687
9688 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
9689 return err
9690 }
9691 if _, err := cw.WriteString(string("references")); err != nil {
9692 return err
9693 }
9694
9695 if len(t.References) > 8192 {
9696 return xerrors.Errorf("Slice value in field t.References was too long")
9697 }
9698
9699 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
9700 return err
9701 }
9702 for _, v := range t.References {
9703 if len(v) > 1000000 {
9704 return xerrors.Errorf("Value in field v was too long")
9705 }
9706
9707 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
9708 return err
9709 }
9710 if _, err := cw.WriteString(string(v)); err != nil {
9711 return err
9712 }
9713
9714 }
9715 }
9716 return nil
9717}
9718
9719func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) {
9720 *t = RepoPull{}
9721
9722 cr := cbg.NewCborReader(r)
9723
9724 maj, extra, err := cr.ReadHeader()
9725 if err != nil {
9726 return err
9727 }
9728 defer func() {
9729 if err == io.EOF {
9730 err = io.ErrUnexpectedEOF
9731 }
9732 }()
9733
9734 if maj != cbg.MajMap {
9735 return fmt.Errorf("cbor input should be of type map")
9736 }
9737
9738 if extra > cbg.MaxLength {
9739 return fmt.Errorf("RepoPull: map struct too large (%d)", extra)
9740 }
9741
9742 n := extra
9743
9744 nameBuf := make([]byte, 10)
9745 for i := uint64(0); i < n; i++ {
9746 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9747 if err != nil {
9748 return err
9749 }
9750
9751 if !ok {
9752 // Field doesn't exist on this type, so ignore it
9753 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9754 return err
9755 }
9756 continue
9757 }
9758
9759 switch string(nameBuf[:nameLen]) {
9760 // t.Body (string) (string)
9761 case "body":
9762
9763 {
9764 b, err := cr.ReadByte()
9765 if err != nil {
9766 return err
9767 }
9768 if b != cbg.CborNull[0] {
9769 if err := cr.UnreadByte(); err != nil {
9770 return err
9771 }
9772
9773 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9774 if err != nil {
9775 return err
9776 }
9777
9778 t.Body = (*string)(&sval)
9779 }
9780 }
9781 // t.LexiconTypeID (string) (string)
9782 case "$type":
9783
9784 {
9785 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9786 if err != nil {
9787 return err
9788 }
9789
9790 t.LexiconTypeID = string(sval)
9791 }
9792 // t.Patch (string) (string)
9793 case "patch":
9794
9795 {
9796 b, err := cr.ReadByte()
9797 if err != nil {
9798 return err
9799 }
9800 if b != cbg.CborNull[0] {
9801 if err := cr.UnreadByte(); err != nil {
9802 return err
9803 }
9804
9805 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9806 if err != nil {
9807 return err
9808 }
9809
9810 t.Patch = (*string)(&sval)
9811 }
9812 }
9813 // t.Title (string) (string)
9814 case "title":
9815
9816 {
9817 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9818 if err != nil {
9819 return err
9820 }
9821
9822 t.Title = string(sval)
9823 }
9824 // t.Source (tangled.RepoPull_Source) (struct)
9825 case "source":
9826
9827 {
9828
9829 b, err := cr.ReadByte()
9830 if err != nil {
9831 return err
9832 }
9833 if b != cbg.CborNull[0] {
9834 if err := cr.UnreadByte(); err != nil {
9835 return err
9836 }
9837 t.Source = new(RepoPull_Source)
9838 if err := t.Source.UnmarshalCBOR(cr); err != nil {
9839 return xerrors.Errorf("unmarshaling t.Source pointer: %w", err)
9840 }
9841 }
9842
9843 }
9844 // t.Target (tangled.RepoPull_Target) (struct)
9845 case "target":
9846
9847 {
9848
9849 b, err := cr.ReadByte()
9850 if err != nil {
9851 return err
9852 }
9853 if b != cbg.CborNull[0] {
9854 if err := cr.UnreadByte(); err != nil {
9855 return err
9856 }
9857 t.Target = new(RepoPull_Target)
9858 if err := t.Target.UnmarshalCBOR(cr); err != nil {
9859 return xerrors.Errorf("unmarshaling t.Target pointer: %w", err)
9860 }
9861 }
9862
9863 }
9864 // t.Mentions ([]string) (slice)
9865 case "mentions":
9866
9867 maj, extra, err = cr.ReadHeader()
9868 if err != nil {
9869 return err
9870 }
9871
9872 if extra > 8192 {
9873 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
9874 }
9875
9876 if maj != cbg.MajArray {
9877 return fmt.Errorf("expected cbor array")
9878 }
9879
9880 if extra > 0 {
9881 t.Mentions = make([]string, extra)
9882 }
9883
9884 for i := 0; i < int(extra); i++ {
9885 {
9886 var maj byte
9887 var extra uint64
9888 var err error
9889 _ = maj
9890 _ = extra
9891 _ = err
9892
9893 {
9894 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9895 if err != nil {
9896 return err
9897 }
9898
9899 t.Mentions[i] = string(sval)
9900 }
9901
9902 }
9903 }
9904 // t.CreatedAt (string) (string)
9905 case "createdAt":
9906
9907 {
9908 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9909 if err != nil {
9910 return err
9911 }
9912
9913 t.CreatedAt = string(sval)
9914 }
9915 // t.PatchBlob (util.LexBlob) (struct)
9916 case "patchBlob":
9917
9918 {
9919
9920 b, err := cr.ReadByte()
9921 if err != nil {
9922 return err
9923 }
9924 if b != cbg.CborNull[0] {
9925 if err := cr.UnreadByte(); err != nil {
9926 return err
9927 }
9928 t.PatchBlob = new(util.LexBlob)
9929 if err := t.PatchBlob.UnmarshalCBOR(cr); err != nil {
9930 return xerrors.Errorf("unmarshaling t.PatchBlob pointer: %w", err)
9931 }
9932 }
9933
9934 }
9935 // t.References ([]string) (slice)
9936 case "references":
9937
9938 maj, extra, err = cr.ReadHeader()
9939 if err != nil {
9940 return err
9941 }
9942
9943 if extra > 8192 {
9944 return fmt.Errorf("t.References: array too large (%d)", extra)
9945 }
9946
9947 if maj != cbg.MajArray {
9948 return fmt.Errorf("expected cbor array")
9949 }
9950
9951 if extra > 0 {
9952 t.References = make([]string, extra)
9953 }
9954
9955 for i := 0; i < int(extra); i++ {
9956 {
9957 var maj byte
9958 var extra uint64
9959 var err error
9960 _ = maj
9961 _ = extra
9962 _ = err
9963
9964 {
9965 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9966 if err != nil {
9967 return err
9968 }
9969
9970 t.References[i] = string(sval)
9971 }
9972
9973 }
9974 }
9975
9976 default:
9977 // Field doesn't exist on this type, so ignore it
9978 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9979 return err
9980 }
9981 }
9982 }
9983
9984 return nil
9985}
9986func (t *RepoPullComment) MarshalCBOR(w io.Writer) error {
9987 if t == nil {
9988 _, err := w.Write(cbg.CborNull)
9989 return err
9990 }
9991
9992 cw := cbg.NewCborWriter(w)
9993 fieldCount := 6
9994
9995 if t.Mentions == nil {
9996 fieldCount--
9997 }
9998
9999 if t.References == nil {
10000 fieldCount--
10001 }
10002
10003 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
10004 return err
10005 }
10006
10007 // t.Body (string) (string)
10008 if len("body") > 1000000 {
10009 return xerrors.Errorf("Value in field \"body\" was too long")
10010 }
10011
10012 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
10013 return err
10014 }
10015 if _, err := cw.WriteString(string("body")); err != nil {
10016 return err
10017 }
10018
10019 if len(t.Body) > 1000000 {
10020 return xerrors.Errorf("Value in field t.Body was too long")
10021 }
10022
10023 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
10024 return err
10025 }
10026 if _, err := cw.WriteString(string(t.Body)); err != nil {
10027 return err
10028 }
10029
10030 // t.Pull (string) (string)
10031 if len("pull") > 1000000 {
10032 return xerrors.Errorf("Value in field \"pull\" was too long")
10033 }
10034
10035 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
10036 return err
10037 }
10038 if _, err := cw.WriteString(string("pull")); err != nil {
10039 return err
10040 }
10041
10042 if len(t.Pull) > 1000000 {
10043 return xerrors.Errorf("Value in field t.Pull was too long")
10044 }
10045
10046 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
10047 return err
10048 }
10049 if _, err := cw.WriteString(string(t.Pull)); err != nil {
10050 return err
10051 }
10052
10053 // t.LexiconTypeID (string) (string)
10054 if len("$type") > 1000000 {
10055 return xerrors.Errorf("Value in field \"$type\" was too long")
10056 }
10057
10058 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
10059 return err
10060 }
10061 if _, err := cw.WriteString(string("$type")); err != nil {
10062 return err
10063 }
10064
10065 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.comment"))); err != nil {
10066 return err
10067 }
10068 if _, err := cw.WriteString(string("sh.tangled.repo.pull.comment")); err != nil {
10069 return err
10070 }
10071
10072 // t.Mentions ([]string) (slice)
10073 if t.Mentions != nil {
10074
10075 if len("mentions") > 1000000 {
10076 return xerrors.Errorf("Value in field \"mentions\" was too long")
10077 }
10078
10079 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
10080 return err
10081 }
10082 if _, err := cw.WriteString(string("mentions")); err != nil {
10083 return err
10084 }
10085
10086 if len(t.Mentions) > 8192 {
10087 return xerrors.Errorf("Slice value in field t.Mentions was too long")
10088 }
10089
10090 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
10091 return err
10092 }
10093 for _, v := range t.Mentions {
10094 if len(v) > 1000000 {
10095 return xerrors.Errorf("Value in field v was too long")
10096 }
10097
10098 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
10099 return err
10100 }
10101 if _, err := cw.WriteString(string(v)); err != nil {
10102 return err
10103 }
10104
10105 }
10106 }
10107
10108 // t.CreatedAt (string) (string)
10109 if len("createdAt") > 1000000 {
10110 return xerrors.Errorf("Value in field \"createdAt\" was too long")
10111 }
10112
10113 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
10114 return err
10115 }
10116 if _, err := cw.WriteString(string("createdAt")); err != nil {
10117 return err
10118 }
10119
10120 if len(t.CreatedAt) > 1000000 {
10121 return xerrors.Errorf("Value in field t.CreatedAt was too long")
10122 }
10123
10124 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
10125 return err
10126 }
10127 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
10128 return err
10129 }
10130
10131 // t.References ([]string) (slice)
10132 if t.References != nil {
10133
10134 if len("references") > 1000000 {
10135 return xerrors.Errorf("Value in field \"references\" was too long")
10136 }
10137
10138 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
10139 return err
10140 }
10141 if _, err := cw.WriteString(string("references")); err != nil {
10142 return err
10143 }
10144
10145 if len(t.References) > 8192 {
10146 return xerrors.Errorf("Slice value in field t.References was too long")
10147 }
10148
10149 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
10150 return err
10151 }
10152 for _, v := range t.References {
10153 if len(v) > 1000000 {
10154 return xerrors.Errorf("Value in field v was too long")
10155 }
10156
10157 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
10158 return err
10159 }
10160 if _, err := cw.WriteString(string(v)); err != nil {
10161 return err
10162 }
10163
10164 }
10165 }
10166 return nil
10167}
10168
10169func (t *RepoPullComment) UnmarshalCBOR(r io.Reader) (err error) {
10170 *t = RepoPullComment{}
10171
10172 cr := cbg.NewCborReader(r)
10173
10174 maj, extra, err := cr.ReadHeader()
10175 if err != nil {
10176 return err
10177 }
10178 defer func() {
10179 if err == io.EOF {
10180 err = io.ErrUnexpectedEOF
10181 }
10182 }()
10183
10184 if maj != cbg.MajMap {
10185 return fmt.Errorf("cbor input should be of type map")
10186 }
10187
10188 if extra > cbg.MaxLength {
10189 return fmt.Errorf("RepoPullComment: map struct too large (%d)", extra)
10190 }
10191
10192 n := extra
10193
10194 nameBuf := make([]byte, 10)
10195 for i := uint64(0); i < n; i++ {
10196 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
10197 if err != nil {
10198 return err
10199 }
10200
10201 if !ok {
10202 // Field doesn't exist on this type, so ignore it
10203 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
10204 return err
10205 }
10206 continue
10207 }
10208
10209 switch string(nameBuf[:nameLen]) {
10210 // t.Body (string) (string)
10211 case "body":
10212
10213 {
10214 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10215 if err != nil {
10216 return err
10217 }
10218
10219 t.Body = string(sval)
10220 }
10221 // t.Pull (string) (string)
10222 case "pull":
10223
10224 {
10225 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10226 if err != nil {
10227 return err
10228 }
10229
10230 t.Pull = string(sval)
10231 }
10232 // t.LexiconTypeID (string) (string)
10233 case "$type":
10234
10235 {
10236 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10237 if err != nil {
10238 return err
10239 }
10240
10241 t.LexiconTypeID = string(sval)
10242 }
10243 // t.Mentions ([]string) (slice)
10244 case "mentions":
10245
10246 maj, extra, err = cr.ReadHeader()
10247 if err != nil {
10248 return err
10249 }
10250
10251 if extra > 8192 {
10252 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
10253 }
10254
10255 if maj != cbg.MajArray {
10256 return fmt.Errorf("expected cbor array")
10257 }
10258
10259 if extra > 0 {
10260 t.Mentions = make([]string, extra)
10261 }
10262
10263 for i := 0; i < int(extra); i++ {
10264 {
10265 var maj byte
10266 var extra uint64
10267 var err error
10268 _ = maj
10269 _ = extra
10270 _ = err
10271
10272 {
10273 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10274 if err != nil {
10275 return err
10276 }
10277
10278 t.Mentions[i] = string(sval)
10279 }
10280
10281 }
10282 }
10283 // t.CreatedAt (string) (string)
10284 case "createdAt":
10285
10286 {
10287 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10288 if err != nil {
10289 return err
10290 }
10291
10292 t.CreatedAt = string(sval)
10293 }
10294 // t.References ([]string) (slice)
10295 case "references":
10296
10297 maj, extra, err = cr.ReadHeader()
10298 if err != nil {
10299 return err
10300 }
10301
10302 if extra > 8192 {
10303 return fmt.Errorf("t.References: array too large (%d)", extra)
10304 }
10305
10306 if maj != cbg.MajArray {
10307 return fmt.Errorf("expected cbor array")
10308 }
10309
10310 if extra > 0 {
10311 t.References = make([]string, extra)
10312 }
10313
10314 for i := 0; i < int(extra); i++ {
10315 {
10316 var maj byte
10317 var extra uint64
10318 var err error
10319 _ = maj
10320 _ = extra
10321 _ = err
10322
10323 {
10324 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10325 if err != nil {
10326 return err
10327 }
10328
10329 t.References[i] = string(sval)
10330 }
10331
10332 }
10333 }
10334
10335 default:
10336 // Field doesn't exist on this type, so ignore it
10337 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
10338 return err
10339 }
10340 }
10341 }
10342
10343 return nil
10344}
10345func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error {
10346 if t == nil {
10347 _, err := w.Write(cbg.CborNull)
10348 return err
10349 }
10350
10351 cw := cbg.NewCborWriter(w)
10352 fieldCount := 3
10353
10354 if t.Repo == nil {
10355 fieldCount--
10356 }
10357
10358 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
10359 return err
10360 }
10361
10362 // t.Sha (string) (string)
10363 if len("sha") > 1000000 {
10364 return xerrors.Errorf("Value in field \"sha\" was too long")
10365 }
10366
10367 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sha"))); err != nil {
10368 return err
10369 }
10370 if _, err := cw.WriteString(string("sha")); err != nil {
10371 return err
10372 }
10373
10374 if len(t.Sha) > 1000000 {
10375 return xerrors.Errorf("Value in field t.Sha was too long")
10376 }
10377
10378 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Sha))); err != nil {
10379 return err
10380 }
10381 if _, err := cw.WriteString(string(t.Sha)); err != nil {
10382 return err
10383 }
10384
10385 // t.Repo (string) (string)
10386 if t.Repo != nil {
10387
10388 if len("repo") > 1000000 {
10389 return xerrors.Errorf("Value in field \"repo\" was too long")
10390 }
10391
10392 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
10393 return err
10394 }
10395 if _, err := cw.WriteString(string("repo")); err != nil {
10396 return err
10397 }
10398
10399 if t.Repo == nil {
10400 if _, err := cw.Write(cbg.CborNull); err != nil {
10401 return err
10402 }
10403 } else {
10404 if len(*t.Repo) > 1000000 {
10405 return xerrors.Errorf("Value in field t.Repo was too long")
10406 }
10407
10408 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
10409 return err
10410 }
10411 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
10412 return err
10413 }
10414 }
10415 }
10416
10417 // t.Branch (string) (string)
10418 if len("branch") > 1000000 {
10419 return xerrors.Errorf("Value in field \"branch\" was too long")
10420 }
10421
10422 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
10423 return err
10424 }
10425 if _, err := cw.WriteString(string("branch")); err != nil {
10426 return err
10427 }
10428
10429 if len(t.Branch) > 1000000 {
10430 return xerrors.Errorf("Value in field t.Branch was too long")
10431 }
10432
10433 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
10434 return err
10435 }
10436 if _, err := cw.WriteString(string(t.Branch)); err != nil {
10437 return err
10438 }
10439 return nil
10440}
10441
10442func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) {
10443 *t = RepoPull_Source{}
10444
10445 cr := cbg.NewCborReader(r)
10446
10447 maj, extra, err := cr.ReadHeader()
10448 if err != nil {
10449 return err
10450 }
10451 defer func() {
10452 if err == io.EOF {
10453 err = io.ErrUnexpectedEOF
10454 }
10455 }()
10456
10457 if maj != cbg.MajMap {
10458 return fmt.Errorf("cbor input should be of type map")
10459 }
10460
10461 if extra > cbg.MaxLength {
10462 return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra)
10463 }
10464
10465 n := extra
10466
10467 nameBuf := make([]byte, 6)
10468 for i := uint64(0); i < n; i++ {
10469 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
10470 if err != nil {
10471 return err
10472 }
10473
10474 if !ok {
10475 // Field doesn't exist on this type, so ignore it
10476 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
10477 return err
10478 }
10479 continue
10480 }
10481
10482 switch string(nameBuf[:nameLen]) {
10483 // t.Sha (string) (string)
10484 case "sha":
10485
10486 {
10487 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10488 if err != nil {
10489 return err
10490 }
10491
10492 t.Sha = string(sval)
10493 }
10494 // t.Repo (string) (string)
10495 case "repo":
10496
10497 {
10498 b, err := cr.ReadByte()
10499 if err != nil {
10500 return err
10501 }
10502 if b != cbg.CborNull[0] {
10503 if err := cr.UnreadByte(); err != nil {
10504 return err
10505 }
10506
10507 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10508 if err != nil {
10509 return err
10510 }
10511
10512 t.Repo = (*string)(&sval)
10513 }
10514 }
10515 // t.Branch (string) (string)
10516 case "branch":
10517
10518 {
10519 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10520 if err != nil {
10521 return err
10522 }
10523
10524 t.Branch = string(sval)
10525 }
10526
10527 default:
10528 // Field doesn't exist on this type, so ignore it
10529 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
10530 return err
10531 }
10532 }
10533 }
10534
10535 return nil
10536}
10537func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error {
10538 if t == nil {
10539 _, err := w.Write(cbg.CborNull)
10540 return err
10541 }
10542
10543 cw := cbg.NewCborWriter(w)
10544
10545 if _, err := cw.Write([]byte{163}); err != nil {
10546 return err
10547 }
10548
10549 // t.Pull (string) (string)
10550 if len("pull") > 1000000 {
10551 return xerrors.Errorf("Value in field \"pull\" was too long")
10552 }
10553
10554 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
10555 return err
10556 }
10557 if _, err := cw.WriteString(string("pull")); err != nil {
10558 return err
10559 }
10560
10561 if len(t.Pull) > 1000000 {
10562 return xerrors.Errorf("Value in field t.Pull was too long")
10563 }
10564
10565 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
10566 return err
10567 }
10568 if _, err := cw.WriteString(string(t.Pull)); err != nil {
10569 return err
10570 }
10571
10572 // t.LexiconTypeID (string) (string)
10573 if len("$type") > 1000000 {
10574 return xerrors.Errorf("Value in field \"$type\" was too long")
10575 }
10576
10577 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
10578 return err
10579 }
10580 if _, err := cw.WriteString(string("$type")); err != nil {
10581 return err
10582 }
10583
10584 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil {
10585 return err
10586 }
10587 if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil {
10588 return err
10589 }
10590
10591 // t.Status (string) (string)
10592 if len("status") > 1000000 {
10593 return xerrors.Errorf("Value in field \"status\" was too long")
10594 }
10595
10596 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
10597 return err
10598 }
10599 if _, err := cw.WriteString(string("status")); err != nil {
10600 return err
10601 }
10602
10603 if len(t.Status) > 1000000 {
10604 return xerrors.Errorf("Value in field t.Status was too long")
10605 }
10606
10607 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
10608 return err
10609 }
10610 if _, err := cw.WriteString(string(t.Status)); err != nil {
10611 return err
10612 }
10613 return nil
10614}
10615
10616func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) {
10617 *t = RepoPullStatus{}
10618
10619 cr := cbg.NewCborReader(r)
10620
10621 maj, extra, err := cr.ReadHeader()
10622 if err != nil {
10623 return err
10624 }
10625 defer func() {
10626 if err == io.EOF {
10627 err = io.ErrUnexpectedEOF
10628 }
10629 }()
10630
10631 if maj != cbg.MajMap {
10632 return fmt.Errorf("cbor input should be of type map")
10633 }
10634
10635 if extra > cbg.MaxLength {
10636 return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra)
10637 }
10638
10639 n := extra
10640
10641 nameBuf := make([]byte, 6)
10642 for i := uint64(0); i < n; i++ {
10643 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
10644 if err != nil {
10645 return err
10646 }
10647
10648 if !ok {
10649 // Field doesn't exist on this type, so ignore it
10650 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
10651 return err
10652 }
10653 continue
10654 }
10655
10656 switch string(nameBuf[:nameLen]) {
10657 // t.Pull (string) (string)
10658 case "pull":
10659
10660 {
10661 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10662 if err != nil {
10663 return err
10664 }
10665
10666 t.Pull = string(sval)
10667 }
10668 // t.LexiconTypeID (string) (string)
10669 case "$type":
10670
10671 {
10672 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10673 if err != nil {
10674 return err
10675 }
10676
10677 t.LexiconTypeID = string(sval)
10678 }
10679 // t.Status (string) (string)
10680 case "status":
10681
10682 {
10683 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10684 if err != nil {
10685 return err
10686 }
10687
10688 t.Status = string(sval)
10689 }
10690
10691 default:
10692 // Field doesn't exist on this type, so ignore it
10693 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
10694 return err
10695 }
10696 }
10697 }
10698
10699 return nil
10700}
10701func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error {
10702 if t == nil {
10703 _, err := w.Write(cbg.CborNull)
10704 return err
10705 }
10706
10707 cw := cbg.NewCborWriter(w)
10708
10709 if _, err := cw.Write([]byte{162}); err != nil {
10710 return err
10711 }
10712
10713 // t.Repo (string) (string)
10714 if len("repo") > 1000000 {
10715 return xerrors.Errorf("Value in field \"repo\" was too long")
10716 }
10717
10718 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
10719 return err
10720 }
10721 if _, err := cw.WriteString(string("repo")); err != nil {
10722 return err
10723 }
10724
10725 if len(t.Repo) > 1000000 {
10726 return xerrors.Errorf("Value in field t.Repo was too long")
10727 }
10728
10729 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
10730 return err
10731 }
10732 if _, err := cw.WriteString(string(t.Repo)); err != nil {
10733 return err
10734 }
10735
10736 // t.Branch (string) (string)
10737 if len("branch") > 1000000 {
10738 return xerrors.Errorf("Value in field \"branch\" was too long")
10739 }
10740
10741 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
10742 return err
10743 }
10744 if _, err := cw.WriteString(string("branch")); err != nil {
10745 return err
10746 }
10747
10748 if len(t.Branch) > 1000000 {
10749 return xerrors.Errorf("Value in field t.Branch was too long")
10750 }
10751
10752 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
10753 return err
10754 }
10755 if _, err := cw.WriteString(string(t.Branch)); err != nil {
10756 return err
10757 }
10758 return nil
10759}
10760
10761func (t *RepoPull_Target) UnmarshalCBOR(r io.Reader) (err error) {
10762 *t = RepoPull_Target{}
10763
10764 cr := cbg.NewCborReader(r)
10765
10766 maj, extra, err := cr.ReadHeader()
10767 if err != nil {
10768 return err
10769 }
10770 defer func() {
10771 if err == io.EOF {
10772 err = io.ErrUnexpectedEOF
10773 }
10774 }()
10775
10776 if maj != cbg.MajMap {
10777 return fmt.Errorf("cbor input should be of type map")
10778 }
10779
10780 if extra > cbg.MaxLength {
10781 return fmt.Errorf("RepoPull_Target: map struct too large (%d)", extra)
10782 }
10783
10784 n := extra
10785
10786 nameBuf := make([]byte, 6)
10787 for i := uint64(0); i < n; i++ {
10788 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
10789 if err != nil {
10790 return err
10791 }
10792
10793 if !ok {
10794 // Field doesn't exist on this type, so ignore it
10795 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
10796 return err
10797 }
10798 continue
10799 }
10800
10801 switch string(nameBuf[:nameLen]) {
10802 // t.Repo (string) (string)
10803 case "repo":
10804
10805 {
10806 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10807 if err != nil {
10808 return err
10809 }
10810
10811 t.Repo = string(sval)
10812 }
10813 // t.Branch (string) (string)
10814 case "branch":
10815
10816 {
10817 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10818 if err != nil {
10819 return err
10820 }
10821
10822 t.Branch = string(sval)
10823 }
10824
10825 default:
10826 // Field doesn't exist on this type, so ignore it
10827 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
10828 return err
10829 }
10830 }
10831 }
10832
10833 return nil
10834}
10835func (t *Spindle) MarshalCBOR(w io.Writer) error {
10836 if t == nil {
10837 _, err := w.Write(cbg.CborNull)
10838 return err
10839 }
10840
10841 cw := cbg.NewCborWriter(w)
10842
10843 if _, err := cw.Write([]byte{162}); err != nil {
10844 return err
10845 }
10846
10847 // t.LexiconTypeID (string) (string)
10848 if len("$type") > 1000000 {
10849 return xerrors.Errorf("Value in field \"$type\" was too long")
10850 }
10851
10852 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
10853 return err
10854 }
10855 if _, err := cw.WriteString(string("$type")); err != nil {
10856 return err
10857 }
10858
10859 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle"))); err != nil {
10860 return err
10861 }
10862 if _, err := cw.WriteString(string("sh.tangled.spindle")); err != nil {
10863 return err
10864 }
10865
10866 // t.CreatedAt (string) (string)
10867 if len("createdAt") > 1000000 {
10868 return xerrors.Errorf("Value in field \"createdAt\" was too long")
10869 }
10870
10871 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
10872 return err
10873 }
10874 if _, err := cw.WriteString(string("createdAt")); err != nil {
10875 return err
10876 }
10877
10878 if len(t.CreatedAt) > 1000000 {
10879 return xerrors.Errorf("Value in field t.CreatedAt was too long")
10880 }
10881
10882 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
10883 return err
10884 }
10885 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
10886 return err
10887 }
10888 return nil
10889}
10890
10891func (t *Spindle) UnmarshalCBOR(r io.Reader) (err error) {
10892 *t = Spindle{}
10893
10894 cr := cbg.NewCborReader(r)
10895
10896 maj, extra, err := cr.ReadHeader()
10897 if err != nil {
10898 return err
10899 }
10900 defer func() {
10901 if err == io.EOF {
10902 err = io.ErrUnexpectedEOF
10903 }
10904 }()
10905
10906 if maj != cbg.MajMap {
10907 return fmt.Errorf("cbor input should be of type map")
10908 }
10909
10910 if extra > cbg.MaxLength {
10911 return fmt.Errorf("Spindle: map struct too large (%d)", extra)
10912 }
10913
10914 n := extra
10915
10916 nameBuf := make([]byte, 9)
10917 for i := uint64(0); i < n; i++ {
10918 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
10919 if err != nil {
10920 return err
10921 }
10922
10923 if !ok {
10924 // Field doesn't exist on this type, so ignore it
10925 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
10926 return err
10927 }
10928 continue
10929 }
10930
10931 switch string(nameBuf[:nameLen]) {
10932 // t.LexiconTypeID (string) (string)
10933 case "$type":
10934
10935 {
10936 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10937 if err != nil {
10938 return err
10939 }
10940
10941 t.LexiconTypeID = string(sval)
10942 }
10943 // t.CreatedAt (string) (string)
10944 case "createdAt":
10945
10946 {
10947 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10948 if err != nil {
10949 return err
10950 }
10951
10952 t.CreatedAt = string(sval)
10953 }
10954
10955 default:
10956 // Field doesn't exist on this type, so ignore it
10957 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
10958 return err
10959 }
10960 }
10961 }
10962
10963 return nil
10964}
10965func (t *SpindleMember) MarshalCBOR(w io.Writer) error {
10966 if t == nil {
10967 _, err := w.Write(cbg.CborNull)
10968 return err
10969 }
10970
10971 cw := cbg.NewCborWriter(w)
10972
10973 if _, err := cw.Write([]byte{164}); err != nil {
10974 return err
10975 }
10976
10977 // t.LexiconTypeID (string) (string)
10978 if len("$type") > 1000000 {
10979 return xerrors.Errorf("Value in field \"$type\" was too long")
10980 }
10981
10982 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
10983 return err
10984 }
10985 if _, err := cw.WriteString(string("$type")); err != nil {
10986 return err
10987 }
10988
10989 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle.member"))); err != nil {
10990 return err
10991 }
10992 if _, err := cw.WriteString(string("sh.tangled.spindle.member")); err != nil {
10993 return err
10994 }
10995
10996 // t.Subject (string) (string)
10997 if len("subject") > 1000000 {
10998 return xerrors.Errorf("Value in field \"subject\" was too long")
10999 }
11000
11001 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
11002 return err
11003 }
11004 if _, err := cw.WriteString(string("subject")); err != nil {
11005 return err
11006 }
11007
11008 if len(t.Subject) > 1000000 {
11009 return xerrors.Errorf("Value in field t.Subject was too long")
11010 }
11011
11012 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
11013 return err
11014 }
11015 if _, err := cw.WriteString(string(t.Subject)); err != nil {
11016 return err
11017 }
11018
11019 // t.Instance (string) (string)
11020 if len("instance") > 1000000 {
11021 return xerrors.Errorf("Value in field \"instance\" was too long")
11022 }
11023
11024 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("instance"))); err != nil {
11025 return err
11026 }
11027 if _, err := cw.WriteString(string("instance")); err != nil {
11028 return err
11029 }
11030
11031 if len(t.Instance) > 1000000 {
11032 return xerrors.Errorf("Value in field t.Instance was too long")
11033 }
11034
11035 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Instance))); err != nil {
11036 return err
11037 }
11038 if _, err := cw.WriteString(string(t.Instance)); err != nil {
11039 return err
11040 }
11041
11042 // t.CreatedAt (string) (string)
11043 if len("createdAt") > 1000000 {
11044 return xerrors.Errorf("Value in field \"createdAt\" was too long")
11045 }
11046
11047 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
11048 return err
11049 }
11050 if _, err := cw.WriteString(string("createdAt")); err != nil {
11051 return err
11052 }
11053
11054 if len(t.CreatedAt) > 1000000 {
11055 return xerrors.Errorf("Value in field t.CreatedAt was too long")
11056 }
11057
11058 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
11059 return err
11060 }
11061 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
11062 return err
11063 }
11064 return nil
11065}
11066
11067func (t *SpindleMember) UnmarshalCBOR(r io.Reader) (err error) {
11068 *t = SpindleMember{}
11069
11070 cr := cbg.NewCborReader(r)
11071
11072 maj, extra, err := cr.ReadHeader()
11073 if err != nil {
11074 return err
11075 }
11076 defer func() {
11077 if err == io.EOF {
11078 err = io.ErrUnexpectedEOF
11079 }
11080 }()
11081
11082 if maj != cbg.MajMap {
11083 return fmt.Errorf("cbor input should be of type map")
11084 }
11085
11086 if extra > cbg.MaxLength {
11087 return fmt.Errorf("SpindleMember: map struct too large (%d)", extra)
11088 }
11089
11090 n := extra
11091
11092 nameBuf := make([]byte, 9)
11093 for i := uint64(0); i < n; i++ {
11094 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
11095 if err != nil {
11096 return err
11097 }
11098
11099 if !ok {
11100 // Field doesn't exist on this type, so ignore it
11101 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
11102 return err
11103 }
11104 continue
11105 }
11106
11107 switch string(nameBuf[:nameLen]) {
11108 // t.LexiconTypeID (string) (string)
11109 case "$type":
11110
11111 {
11112 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11113 if err != nil {
11114 return err
11115 }
11116
11117 t.LexiconTypeID = string(sval)
11118 }
11119 // t.Subject (string) (string)
11120 case "subject":
11121
11122 {
11123 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11124 if err != nil {
11125 return err
11126 }
11127
11128 t.Subject = string(sval)
11129 }
11130 // t.Instance (string) (string)
11131 case "instance":
11132
11133 {
11134 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11135 if err != nil {
11136 return err
11137 }
11138
11139 t.Instance = string(sval)
11140 }
11141 // t.CreatedAt (string) (string)
11142 case "createdAt":
11143
11144 {
11145 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11146 if err != nil {
11147 return err
11148 }
11149
11150 t.CreatedAt = string(sval)
11151 }
11152
11153 default:
11154 // Field doesn't exist on this type, so ignore it
11155 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
11156 return err
11157 }
11158 }
11159 }
11160
11161 return nil
11162}
11163func (t *String) MarshalCBOR(w io.Writer) error {
11164 if t == nil {
11165 _, err := w.Write(cbg.CborNull)
11166 return err
11167 }
11168
11169 cw := cbg.NewCborWriter(w)
11170
11171 if _, err := cw.Write([]byte{165}); err != nil {
11172 return err
11173 }
11174
11175 // t.LexiconTypeID (string) (string)
11176 if len("$type") > 1000000 {
11177 return xerrors.Errorf("Value in field \"$type\" was too long")
11178 }
11179
11180 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
11181 return err
11182 }
11183 if _, err := cw.WriteString(string("$type")); err != nil {
11184 return err
11185 }
11186
11187 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.string"))); err != nil {
11188 return err
11189 }
11190 if _, err := cw.WriteString(string("sh.tangled.string")); err != nil {
11191 return err
11192 }
11193
11194 // t.Contents (string) (string)
11195 if len("contents") > 1000000 {
11196 return xerrors.Errorf("Value in field \"contents\" was too long")
11197 }
11198
11199 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("contents"))); err != nil {
11200 return err
11201 }
11202 if _, err := cw.WriteString(string("contents")); err != nil {
11203 return err
11204 }
11205
11206 if len(t.Contents) > 1000000 {
11207 return xerrors.Errorf("Value in field t.Contents was too long")
11208 }
11209
11210 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Contents))); err != nil {
11211 return err
11212 }
11213 if _, err := cw.WriteString(string(t.Contents)); err != nil {
11214 return err
11215 }
11216
11217 // t.Filename (string) (string)
11218 if len("filename") > 1000000 {
11219 return xerrors.Errorf("Value in field \"filename\" was too long")
11220 }
11221
11222 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("filename"))); err != nil {
11223 return err
11224 }
11225 if _, err := cw.WriteString(string("filename")); err != nil {
11226 return err
11227 }
11228
11229 if len(t.Filename) > 1000000 {
11230 return xerrors.Errorf("Value in field t.Filename was too long")
11231 }
11232
11233 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Filename))); err != nil {
11234 return err
11235 }
11236 if _, err := cw.WriteString(string(t.Filename)); err != nil {
11237 return err
11238 }
11239
11240 // t.CreatedAt (string) (string)
11241 if len("createdAt") > 1000000 {
11242 return xerrors.Errorf("Value in field \"createdAt\" was too long")
11243 }
11244
11245 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
11246 return err
11247 }
11248 if _, err := cw.WriteString(string("createdAt")); err != nil {
11249 return err
11250 }
11251
11252 if len(t.CreatedAt) > 1000000 {
11253 return xerrors.Errorf("Value in field t.CreatedAt was too long")
11254 }
11255
11256 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
11257 return err
11258 }
11259 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
11260 return err
11261 }
11262
11263 // t.Description (string) (string)
11264 if len("description") > 1000000 {
11265 return xerrors.Errorf("Value in field \"description\" was too long")
11266 }
11267
11268 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
11269 return err
11270 }
11271 if _, err := cw.WriteString(string("description")); err != nil {
11272 return err
11273 }
11274
11275 if len(t.Description) > 1000000 {
11276 return xerrors.Errorf("Value in field t.Description was too long")
11277 }
11278
11279 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil {
11280 return err
11281 }
11282 if _, err := cw.WriteString(string(t.Description)); err != nil {
11283 return err
11284 }
11285 return nil
11286}
11287
11288func (t *String) UnmarshalCBOR(r io.Reader) (err error) {
11289 *t = String{}
11290
11291 cr := cbg.NewCborReader(r)
11292
11293 maj, extra, err := cr.ReadHeader()
11294 if err != nil {
11295 return err
11296 }
11297 defer func() {
11298 if err == io.EOF {
11299 err = io.ErrUnexpectedEOF
11300 }
11301 }()
11302
11303 if maj != cbg.MajMap {
11304 return fmt.Errorf("cbor input should be of type map")
11305 }
11306
11307 if extra > cbg.MaxLength {
11308 return fmt.Errorf("String: map struct too large (%d)", extra)
11309 }
11310
11311 n := extra
11312
11313 nameBuf := make([]byte, 11)
11314 for i := uint64(0); i < n; i++ {
11315 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
11316 if err != nil {
11317 return err
11318 }
11319
11320 if !ok {
11321 // Field doesn't exist on this type, so ignore it
11322 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
11323 return err
11324 }
11325 continue
11326 }
11327
11328 switch string(nameBuf[:nameLen]) {
11329 // t.LexiconTypeID (string) (string)
11330 case "$type":
11331
11332 {
11333 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11334 if err != nil {
11335 return err
11336 }
11337
11338 t.LexiconTypeID = string(sval)
11339 }
11340 // t.Contents (string) (string)
11341 case "contents":
11342
11343 {
11344 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11345 if err != nil {
11346 return err
11347 }
11348
11349 t.Contents = string(sval)
11350 }
11351 // t.Filename (string) (string)
11352 case "filename":
11353
11354 {
11355 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11356 if err != nil {
11357 return err
11358 }
11359
11360 t.Filename = string(sval)
11361 }
11362 // t.CreatedAt (string) (string)
11363 case "createdAt":
11364
11365 {
11366 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11367 if err != nil {
11368 return err
11369 }
11370
11371 t.CreatedAt = string(sval)
11372 }
11373 // t.Description (string) (string)
11374 case "description":
11375
11376 {
11377 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11378 if err != nil {
11379 return err
11380 }
11381
11382 t.Description = string(sval)
11383 }
11384
11385 default:
11386 // Field doesn't exist on this type, so ignore it
11387 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
11388 return err
11389 }
11390 }
11391 }
11392
11393 return nil
11394}