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