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