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