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