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