veryroundbird.house
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 *FeedStar) 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
30 if _, err := cw.Write([]byte{163}); err != nil {
31 return err
32 }
33
34 // t.LexiconTypeID (string) (string)
35 if len("$type") > 1000000 {
36 return xerrors.Errorf("Value in field \"$type\" was too long")
37 }
38
39 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
40 return err
41 }
42 if _, err := cw.WriteString(string("$type")); err != nil {
43 return err
44 }
45
46 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.star"))); err != nil {
47 return err
48 }
49 if _, err := cw.WriteString(string("sh.tangled.feed.star")); err != nil {
50 return err
51 }
52
53 // t.Subject (string) (string)
54 if len("subject") > 1000000 {
55 return xerrors.Errorf("Value in field \"subject\" was too long")
56 }
57
58 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
59 return err
60 }
61 if _, err := cw.WriteString(string("subject")); err != nil {
62 return err
63 }
64
65 if len(t.Subject) > 1000000 {
66 return xerrors.Errorf("Value in field t.Subject was too long")
67 }
68
69 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
70 return err
71 }
72 if _, err := cw.WriteString(string(t.Subject)); err != nil {
73 return err
74 }
75
76 // t.CreatedAt (string) (string)
77 if len("createdAt") > 1000000 {
78 return xerrors.Errorf("Value in field \"createdAt\" was too long")
79 }
80
81 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
82 return err
83 }
84 if _, err := cw.WriteString(string("createdAt")); err != nil {
85 return err
86 }
87
88 if len(t.CreatedAt) > 1000000 {
89 return xerrors.Errorf("Value in field t.CreatedAt was too long")
90 }
91
92 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
93 return err
94 }
95 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
96 return err
97 }
98 return nil
99}
100
101func (t *FeedStar) UnmarshalCBOR(r io.Reader) (err error) {
102 *t = FeedStar{}
103
104 cr := cbg.NewCborReader(r)
105
106 maj, extra, err := cr.ReadHeader()
107 if err != nil {
108 return err
109 }
110 defer func() {
111 if err == io.EOF {
112 err = io.ErrUnexpectedEOF
113 }
114 }()
115
116 if maj != cbg.MajMap {
117 return fmt.Errorf("cbor input should be of type map")
118 }
119
120 if extra > cbg.MaxLength {
121 return fmt.Errorf("FeedStar: map struct too large (%d)", extra)
122 }
123
124 n := extra
125
126 nameBuf := make([]byte, 9)
127 for i := uint64(0); i < n; i++ {
128 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
129 if err != nil {
130 return err
131 }
132
133 if !ok {
134 // Field doesn't exist on this type, so ignore it
135 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
136 return err
137 }
138 continue
139 }
140
141 switch string(nameBuf[:nameLen]) {
142 // t.LexiconTypeID (string) (string)
143 case "$type":
144
145 {
146 sval, err := cbg.ReadStringWithMax(cr, 1000000)
147 if err != nil {
148 return err
149 }
150
151 t.LexiconTypeID = string(sval)
152 }
153 // t.Subject (string) (string)
154 case "subject":
155
156 {
157 sval, err := cbg.ReadStringWithMax(cr, 1000000)
158 if err != nil {
159 return err
160 }
161
162 t.Subject = string(sval)
163 }
164 // t.CreatedAt (string) (string)
165 case "createdAt":
166
167 {
168 sval, err := cbg.ReadStringWithMax(cr, 1000000)
169 if err != nil {
170 return err
171 }
172
173 t.CreatedAt = string(sval)
174 }
175
176 default:
177 // Field doesn't exist on this type, so ignore it
178 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
179 return err
180 }
181 }
182 }
183
184 return nil
185}
186func (t *GraphFollow) MarshalCBOR(w io.Writer) error {
187 if t == nil {
188 _, err := w.Write(cbg.CborNull)
189 return err
190 }
191
192 cw := cbg.NewCborWriter(w)
193
194 if _, err := cw.Write([]byte{163}); err != nil {
195 return err
196 }
197
198 // t.LexiconTypeID (string) (string)
199 if len("$type") > 1000000 {
200 return xerrors.Errorf("Value in field \"$type\" was too long")
201 }
202
203 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
204 return err
205 }
206 if _, err := cw.WriteString(string("$type")); err != nil {
207 return err
208 }
209
210 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.graph.follow"))); err != nil {
211 return err
212 }
213 if _, err := cw.WriteString(string("sh.tangled.graph.follow")); err != nil {
214 return err
215 }
216
217 // t.Subject (string) (string)
218 if len("subject") > 1000000 {
219 return xerrors.Errorf("Value in field \"subject\" was too long")
220 }
221
222 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
223 return err
224 }
225 if _, err := cw.WriteString(string("subject")); err != nil {
226 return err
227 }
228
229 if len(t.Subject) > 1000000 {
230 return xerrors.Errorf("Value in field t.Subject was too long")
231 }
232
233 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
234 return err
235 }
236 if _, err := cw.WriteString(string(t.Subject)); err != nil {
237 return err
238 }
239
240 // t.CreatedAt (string) (string)
241 if len("createdAt") > 1000000 {
242 return xerrors.Errorf("Value in field \"createdAt\" was too long")
243 }
244
245 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
246 return err
247 }
248 if _, err := cw.WriteString(string("createdAt")); err != nil {
249 return err
250 }
251
252 if len(t.CreatedAt) > 1000000 {
253 return xerrors.Errorf("Value in field t.CreatedAt was too long")
254 }
255
256 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
257 return err
258 }
259 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
260 return err
261 }
262 return nil
263}
264
265func (t *GraphFollow) UnmarshalCBOR(r io.Reader) (err error) {
266 *t = GraphFollow{}
267
268 cr := cbg.NewCborReader(r)
269
270 maj, extra, err := cr.ReadHeader()
271 if err != nil {
272 return err
273 }
274 defer func() {
275 if err == io.EOF {
276 err = io.ErrUnexpectedEOF
277 }
278 }()
279
280 if maj != cbg.MajMap {
281 return fmt.Errorf("cbor input should be of type map")
282 }
283
284 if extra > cbg.MaxLength {
285 return fmt.Errorf("GraphFollow: map struct too large (%d)", extra)
286 }
287
288 n := extra
289
290 nameBuf := make([]byte, 9)
291 for i := uint64(0); i < n; i++ {
292 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
293 if err != nil {
294 return err
295 }
296
297 if !ok {
298 // Field doesn't exist on this type, so ignore it
299 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
300 return err
301 }
302 continue
303 }
304
305 switch string(nameBuf[:nameLen]) {
306 // t.LexiconTypeID (string) (string)
307 case "$type":
308
309 {
310 sval, err := cbg.ReadStringWithMax(cr, 1000000)
311 if err != nil {
312 return err
313 }
314
315 t.LexiconTypeID = string(sval)
316 }
317 // t.Subject (string) (string)
318 case "subject":
319
320 {
321 sval, err := cbg.ReadStringWithMax(cr, 1000000)
322 if err != nil {
323 return err
324 }
325
326 t.Subject = string(sval)
327 }
328 // t.CreatedAt (string) (string)
329 case "createdAt":
330
331 {
332 sval, err := cbg.ReadStringWithMax(cr, 1000000)
333 if err != nil {
334 return err
335 }
336
337 t.CreatedAt = string(sval)
338 }
339
340 default:
341 // Field doesn't exist on this type, so ignore it
342 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
343 return err
344 }
345 }
346 }
347
348 return nil
349}
350func (t *KnotMember) MarshalCBOR(w io.Writer) error {
351 if t == nil {
352 _, err := w.Write(cbg.CborNull)
353 return err
354 }
355
356 cw := cbg.NewCborWriter(w)
357
358 if _, err := cw.Write([]byte{164}); err != nil {
359 return err
360 }
361
362 // t.LexiconTypeID (string) (string)
363 if len("$type") > 1000000 {
364 return xerrors.Errorf("Value in field \"$type\" was too long")
365 }
366
367 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
368 return err
369 }
370 if _, err := cw.WriteString(string("$type")); err != nil {
371 return err
372 }
373
374 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot.member"))); err != nil {
375 return err
376 }
377 if _, err := cw.WriteString(string("sh.tangled.knot.member")); err != nil {
378 return err
379 }
380
381 // t.Domain (string) (string)
382 if len("domain") > 1000000 {
383 return xerrors.Errorf("Value in field \"domain\" was too long")
384 }
385
386 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("domain"))); err != nil {
387 return err
388 }
389 if _, err := cw.WriteString(string("domain")); err != nil {
390 return err
391 }
392
393 if len(t.Domain) > 1000000 {
394 return xerrors.Errorf("Value in field t.Domain was too long")
395 }
396
397 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Domain))); err != nil {
398 return err
399 }
400 if _, err := cw.WriteString(string(t.Domain)); err != nil {
401 return err
402 }
403
404 // t.Subject (string) (string)
405 if len("subject") > 1000000 {
406 return xerrors.Errorf("Value in field \"subject\" was too long")
407 }
408
409 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
410 return err
411 }
412 if _, err := cw.WriteString(string("subject")); err != nil {
413 return err
414 }
415
416 if len(t.Subject) > 1000000 {
417 return xerrors.Errorf("Value in field t.Subject was too long")
418 }
419
420 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
421 return err
422 }
423 if _, err := cw.WriteString(string(t.Subject)); err != nil {
424 return err
425 }
426
427 // t.CreatedAt (string) (string)
428 if len("createdAt") > 1000000 {
429 return xerrors.Errorf("Value in field \"createdAt\" was too long")
430 }
431
432 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
433 return err
434 }
435 if _, err := cw.WriteString(string("createdAt")); err != nil {
436 return err
437 }
438
439 if len(t.CreatedAt) > 1000000 {
440 return xerrors.Errorf("Value in field t.CreatedAt was too long")
441 }
442
443 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
444 return err
445 }
446 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
447 return err
448 }
449 return nil
450}
451
452func (t *KnotMember) UnmarshalCBOR(r io.Reader) (err error) {
453 *t = KnotMember{}
454
455 cr := cbg.NewCborReader(r)
456
457 maj, extra, err := cr.ReadHeader()
458 if err != nil {
459 return err
460 }
461 defer func() {
462 if err == io.EOF {
463 err = io.ErrUnexpectedEOF
464 }
465 }()
466
467 if maj != cbg.MajMap {
468 return fmt.Errorf("cbor input should be of type map")
469 }
470
471 if extra > cbg.MaxLength {
472 return fmt.Errorf("KnotMember: map struct too large (%d)", extra)
473 }
474
475 n := extra
476
477 nameBuf := make([]byte, 9)
478 for i := uint64(0); i < n; i++ {
479 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
480 if err != nil {
481 return err
482 }
483
484 if !ok {
485 // Field doesn't exist on this type, so ignore it
486 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
487 return err
488 }
489 continue
490 }
491
492 switch string(nameBuf[:nameLen]) {
493 // t.LexiconTypeID (string) (string)
494 case "$type":
495
496 {
497 sval, err := cbg.ReadStringWithMax(cr, 1000000)
498 if err != nil {
499 return err
500 }
501
502 t.LexiconTypeID = string(sval)
503 }
504 // t.Domain (string) (string)
505 case "domain":
506
507 {
508 sval, err := cbg.ReadStringWithMax(cr, 1000000)
509 if err != nil {
510 return err
511 }
512
513 t.Domain = string(sval)
514 }
515 // t.Subject (string) (string)
516 case "subject":
517
518 {
519 sval, err := cbg.ReadStringWithMax(cr, 1000000)
520 if err != nil {
521 return err
522 }
523
524 t.Subject = string(sval)
525 }
526 // t.CreatedAt (string) (string)
527 case "createdAt":
528
529 {
530 sval, err := cbg.ReadStringWithMax(cr, 1000000)
531 if err != nil {
532 return err
533 }
534
535 t.CreatedAt = string(sval)
536 }
537
538 default:
539 // Field doesn't exist on this type, so ignore it
540 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
541 return err
542 }
543 }
544 }
545
546 return nil
547}
548func (t *PublicKey) MarshalCBOR(w io.Writer) error {
549 if t == nil {
550 _, err := w.Write(cbg.CborNull)
551 return err
552 }
553
554 cw := cbg.NewCborWriter(w)
555
556 if _, err := cw.Write([]byte{164}); err != nil {
557 return err
558 }
559
560 // t.Key (string) (string)
561 if len("key") > 1000000 {
562 return xerrors.Errorf("Value in field \"key\" was too long")
563 }
564
565 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
566 return err
567 }
568 if _, err := cw.WriteString(string("key")); err != nil {
569 return err
570 }
571
572 if len(t.Key) > 1000000 {
573 return xerrors.Errorf("Value in field t.Key was too long")
574 }
575
576 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
577 return err
578 }
579 if _, err := cw.WriteString(string(t.Key)); err != nil {
580 return err
581 }
582
583 // t.Name (string) (string)
584 if len("name") > 1000000 {
585 return xerrors.Errorf("Value in field \"name\" was too long")
586 }
587
588 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
589 return err
590 }
591 if _, err := cw.WriteString(string("name")); err != nil {
592 return err
593 }
594
595 if len(t.Name) > 1000000 {
596 return xerrors.Errorf("Value in field t.Name was too long")
597 }
598
599 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
600 return err
601 }
602 if _, err := cw.WriteString(string(t.Name)); err != nil {
603 return err
604 }
605
606 // t.LexiconTypeID (string) (string)
607 if len("$type") > 1000000 {
608 return xerrors.Errorf("Value in field \"$type\" was too long")
609 }
610
611 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
612 return err
613 }
614 if _, err := cw.WriteString(string("$type")); err != nil {
615 return err
616 }
617
618 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil {
619 return err
620 }
621 if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil {
622 return err
623 }
624
625 // t.CreatedAt (string) (string)
626 if len("createdAt") > 1000000 {
627 return xerrors.Errorf("Value in field \"createdAt\" was too long")
628 }
629
630 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
631 return err
632 }
633 if _, err := cw.WriteString(string("createdAt")); err != nil {
634 return err
635 }
636
637 if len(t.CreatedAt) > 1000000 {
638 return xerrors.Errorf("Value in field t.CreatedAt was too long")
639 }
640
641 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
642 return err
643 }
644 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
645 return err
646 }
647 return nil
648}
649
650func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) {
651 *t = PublicKey{}
652
653 cr := cbg.NewCborReader(r)
654
655 maj, extra, err := cr.ReadHeader()
656 if err != nil {
657 return err
658 }
659 defer func() {
660 if err == io.EOF {
661 err = io.ErrUnexpectedEOF
662 }
663 }()
664
665 if maj != cbg.MajMap {
666 return fmt.Errorf("cbor input should be of type map")
667 }
668
669 if extra > cbg.MaxLength {
670 return fmt.Errorf("PublicKey: map struct too large (%d)", extra)
671 }
672
673 n := extra
674
675 nameBuf := make([]byte, 9)
676 for i := uint64(0); i < n; i++ {
677 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
678 if err != nil {
679 return err
680 }
681
682 if !ok {
683 // Field doesn't exist on this type, so ignore it
684 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
685 return err
686 }
687 continue
688 }
689
690 switch string(nameBuf[:nameLen]) {
691 // t.Key (string) (string)
692 case "key":
693
694 {
695 sval, err := cbg.ReadStringWithMax(cr, 1000000)
696 if err != nil {
697 return err
698 }
699
700 t.Key = string(sval)
701 }
702 // t.Name (string) (string)
703 case "name":
704
705 {
706 sval, err := cbg.ReadStringWithMax(cr, 1000000)
707 if err != nil {
708 return err
709 }
710
711 t.Name = string(sval)
712 }
713 // t.LexiconTypeID (string) (string)
714 case "$type":
715
716 {
717 sval, err := cbg.ReadStringWithMax(cr, 1000000)
718 if err != nil {
719 return err
720 }
721
722 t.LexiconTypeID = string(sval)
723 }
724 // t.CreatedAt (string) (string)
725 case "createdAt":
726
727 {
728 sval, err := cbg.ReadStringWithMax(cr, 1000000)
729 if err != nil {
730 return err
731 }
732
733 t.CreatedAt = string(sval)
734 }
735
736 default:
737 // Field doesn't exist on this type, so ignore it
738 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
739 return err
740 }
741 }
742 }
743
744 return nil
745}
746func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error {
747 if t == nil {
748 _, err := w.Write(cbg.CborNull)
749 return err
750 }
751
752 cw := cbg.NewCborWriter(w)
753 fieldCount := 7
754
755 if t.CommentId == nil {
756 fieldCount--
757 }
758
759 if t.Owner == nil {
760 fieldCount--
761 }
762
763 if t.Repo == nil {
764 fieldCount--
765 }
766
767 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
768 return err
769 }
770
771 // t.Body (string) (string)
772 if len("body") > 1000000 {
773 return xerrors.Errorf("Value in field \"body\" was too long")
774 }
775
776 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
777 return err
778 }
779 if _, err := cw.WriteString(string("body")); err != nil {
780 return err
781 }
782
783 if len(t.Body) > 1000000 {
784 return xerrors.Errorf("Value in field t.Body was too long")
785 }
786
787 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
788 return err
789 }
790 if _, err := cw.WriteString(string(t.Body)); err != nil {
791 return err
792 }
793
794 // t.Repo (string) (string)
795 if t.Repo != nil {
796
797 if len("repo") > 1000000 {
798 return xerrors.Errorf("Value in field \"repo\" was too long")
799 }
800
801 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
802 return err
803 }
804 if _, err := cw.WriteString(string("repo")); err != nil {
805 return err
806 }
807
808 if t.Repo == nil {
809 if _, err := cw.Write(cbg.CborNull); err != nil {
810 return err
811 }
812 } else {
813 if len(*t.Repo) > 1000000 {
814 return xerrors.Errorf("Value in field t.Repo was too long")
815 }
816
817 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
818 return err
819 }
820 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
821 return err
822 }
823 }
824 }
825
826 // t.LexiconTypeID (string) (string)
827 if len("$type") > 1000000 {
828 return xerrors.Errorf("Value in field \"$type\" was too long")
829 }
830
831 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
832 return err
833 }
834 if _, err := cw.WriteString(string("$type")); err != nil {
835 return err
836 }
837
838 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil {
839 return err
840 }
841 if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil {
842 return err
843 }
844
845 // t.Issue (string) (string)
846 if len("issue") > 1000000 {
847 return xerrors.Errorf("Value in field \"issue\" was too long")
848 }
849
850 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
851 return err
852 }
853 if _, err := cw.WriteString(string("issue")); err != nil {
854 return err
855 }
856
857 if len(t.Issue) > 1000000 {
858 return xerrors.Errorf("Value in field t.Issue was too long")
859 }
860
861 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
862 return err
863 }
864 if _, err := cw.WriteString(string(t.Issue)); err != nil {
865 return err
866 }
867
868 // t.Owner (string) (string)
869 if t.Owner != nil {
870
871 if len("owner") > 1000000 {
872 return xerrors.Errorf("Value in field \"owner\" was too long")
873 }
874
875 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
876 return err
877 }
878 if _, err := cw.WriteString(string("owner")); err != nil {
879 return err
880 }
881
882 if t.Owner == nil {
883 if _, err := cw.Write(cbg.CborNull); err != nil {
884 return err
885 }
886 } else {
887 if len(*t.Owner) > 1000000 {
888 return xerrors.Errorf("Value in field t.Owner was too long")
889 }
890
891 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Owner))); err != nil {
892 return err
893 }
894 if _, err := cw.WriteString(string(*t.Owner)); err != nil {
895 return err
896 }
897 }
898 }
899
900 // t.CommentId (int64) (int64)
901 if t.CommentId != nil {
902
903 if len("commentId") > 1000000 {
904 return xerrors.Errorf("Value in field \"commentId\" was too long")
905 }
906
907 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commentId"))); err != nil {
908 return err
909 }
910 if _, err := cw.WriteString(string("commentId")); err != nil {
911 return err
912 }
913
914 if t.CommentId == nil {
915 if _, err := cw.Write(cbg.CborNull); err != nil {
916 return err
917 }
918 } else {
919 if *t.CommentId >= 0 {
920 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.CommentId)); err != nil {
921 return err
922 }
923 } else {
924 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.CommentId-1)); err != nil {
925 return err
926 }
927 }
928 }
929
930 }
931
932 // t.CreatedAt (string) (string)
933 if len("createdAt") > 1000000 {
934 return xerrors.Errorf("Value in field \"createdAt\" was too long")
935 }
936
937 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
938 return err
939 }
940 if _, err := cw.WriteString(string("createdAt")); err != nil {
941 return err
942 }
943
944 if len(t.CreatedAt) > 1000000 {
945 return xerrors.Errorf("Value in field t.CreatedAt was too long")
946 }
947
948 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
949 return err
950 }
951 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
952 return err
953 }
954 return nil
955}
956
957func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) {
958 *t = RepoIssueComment{}
959
960 cr := cbg.NewCborReader(r)
961
962 maj, extra, err := cr.ReadHeader()
963 if err != nil {
964 return err
965 }
966 defer func() {
967 if err == io.EOF {
968 err = io.ErrUnexpectedEOF
969 }
970 }()
971
972 if maj != cbg.MajMap {
973 return fmt.Errorf("cbor input should be of type map")
974 }
975
976 if extra > cbg.MaxLength {
977 return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra)
978 }
979
980 n := extra
981
982 nameBuf := make([]byte, 9)
983 for i := uint64(0); i < n; i++ {
984 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
985 if err != nil {
986 return err
987 }
988
989 if !ok {
990 // Field doesn't exist on this type, so ignore it
991 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
992 return err
993 }
994 continue
995 }
996
997 switch string(nameBuf[:nameLen]) {
998 // t.Body (string) (string)
999 case "body":
1000
1001 {
1002 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1003 if err != nil {
1004 return err
1005 }
1006
1007 t.Body = string(sval)
1008 }
1009 // t.Repo (string) (string)
1010 case "repo":
1011
1012 {
1013 b, err := cr.ReadByte()
1014 if err != nil {
1015 return err
1016 }
1017 if b != cbg.CborNull[0] {
1018 if err := cr.UnreadByte(); err != nil {
1019 return err
1020 }
1021
1022 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1023 if err != nil {
1024 return err
1025 }
1026
1027 t.Repo = (*string)(&sval)
1028 }
1029 }
1030 // t.LexiconTypeID (string) (string)
1031 case "$type":
1032
1033 {
1034 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1035 if err != nil {
1036 return err
1037 }
1038
1039 t.LexiconTypeID = string(sval)
1040 }
1041 // t.Issue (string) (string)
1042 case "issue":
1043
1044 {
1045 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1046 if err != nil {
1047 return err
1048 }
1049
1050 t.Issue = string(sval)
1051 }
1052 // t.Owner (string) (string)
1053 case "owner":
1054
1055 {
1056 b, err := cr.ReadByte()
1057 if err != nil {
1058 return err
1059 }
1060 if b != cbg.CborNull[0] {
1061 if err := cr.UnreadByte(); err != nil {
1062 return err
1063 }
1064
1065 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1066 if err != nil {
1067 return err
1068 }
1069
1070 t.Owner = (*string)(&sval)
1071 }
1072 }
1073 // t.CommentId (int64) (int64)
1074 case "commentId":
1075 {
1076
1077 b, err := cr.ReadByte()
1078 if err != nil {
1079 return err
1080 }
1081 if b != cbg.CborNull[0] {
1082 if err := cr.UnreadByte(); err != nil {
1083 return err
1084 }
1085 maj, extra, err := cr.ReadHeader()
1086 if err != nil {
1087 return err
1088 }
1089 var extraI int64
1090 switch maj {
1091 case cbg.MajUnsignedInt:
1092 extraI = int64(extra)
1093 if extraI < 0 {
1094 return fmt.Errorf("int64 positive overflow")
1095 }
1096 case cbg.MajNegativeInt:
1097 extraI = int64(extra)
1098 if extraI < 0 {
1099 return fmt.Errorf("int64 negative overflow")
1100 }
1101 extraI = -1 - extraI
1102 default:
1103 return fmt.Errorf("wrong type for int64 field: %d", maj)
1104 }
1105
1106 t.CommentId = (*int64)(&extraI)
1107 }
1108 }
1109 // t.CreatedAt (string) (string)
1110 case "createdAt":
1111
1112 {
1113 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1114 if err != nil {
1115 return err
1116 }
1117
1118 t.CreatedAt = string(sval)
1119 }
1120
1121 default:
1122 // Field doesn't exist on this type, so ignore it
1123 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1124 return err
1125 }
1126 }
1127 }
1128
1129 return nil
1130}
1131func (t *RepoIssueState) MarshalCBOR(w io.Writer) error {
1132 if t == nil {
1133 _, err := w.Write(cbg.CborNull)
1134 return err
1135 }
1136
1137 cw := cbg.NewCborWriter(w)
1138
1139 if _, err := cw.Write([]byte{163}); err != nil {
1140 return err
1141 }
1142
1143 // t.LexiconTypeID (string) (string)
1144 if len("$type") > 1000000 {
1145 return xerrors.Errorf("Value in field \"$type\" was too long")
1146 }
1147
1148 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
1149 return err
1150 }
1151 if _, err := cw.WriteString(string("$type")); err != nil {
1152 return err
1153 }
1154
1155 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil {
1156 return err
1157 }
1158 if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil {
1159 return err
1160 }
1161
1162 // t.Issue (string) (string)
1163 if len("issue") > 1000000 {
1164 return xerrors.Errorf("Value in field \"issue\" was too long")
1165 }
1166
1167 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
1168 return err
1169 }
1170 if _, err := cw.WriteString(string("issue")); err != nil {
1171 return err
1172 }
1173
1174 if len(t.Issue) > 1000000 {
1175 return xerrors.Errorf("Value in field t.Issue was too long")
1176 }
1177
1178 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
1179 return err
1180 }
1181 if _, err := cw.WriteString(string(t.Issue)); err != nil {
1182 return err
1183 }
1184
1185 // t.State (string) (string)
1186 if len("state") > 1000000 {
1187 return xerrors.Errorf("Value in field \"state\" was too long")
1188 }
1189
1190 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil {
1191 return err
1192 }
1193 if _, err := cw.WriteString(string("state")); err != nil {
1194 return err
1195 }
1196
1197 if len(t.State) > 1000000 {
1198 return xerrors.Errorf("Value in field t.State was too long")
1199 }
1200
1201 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil {
1202 return err
1203 }
1204 if _, err := cw.WriteString(string(t.State)); err != nil {
1205 return err
1206 }
1207 return nil
1208}
1209
1210func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) {
1211 *t = RepoIssueState{}
1212
1213 cr := cbg.NewCborReader(r)
1214
1215 maj, extra, err := cr.ReadHeader()
1216 if err != nil {
1217 return err
1218 }
1219 defer func() {
1220 if err == io.EOF {
1221 err = io.ErrUnexpectedEOF
1222 }
1223 }()
1224
1225 if maj != cbg.MajMap {
1226 return fmt.Errorf("cbor input should be of type map")
1227 }
1228
1229 if extra > cbg.MaxLength {
1230 return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra)
1231 }
1232
1233 n := extra
1234
1235 nameBuf := make([]byte, 5)
1236 for i := uint64(0); i < n; i++ {
1237 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1238 if err != nil {
1239 return err
1240 }
1241
1242 if !ok {
1243 // Field doesn't exist on this type, so ignore it
1244 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1245 return err
1246 }
1247 continue
1248 }
1249
1250 switch string(nameBuf[:nameLen]) {
1251 // t.LexiconTypeID (string) (string)
1252 case "$type":
1253
1254 {
1255 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1256 if err != nil {
1257 return err
1258 }
1259
1260 t.LexiconTypeID = string(sval)
1261 }
1262 // t.Issue (string) (string)
1263 case "issue":
1264
1265 {
1266 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1267 if err != nil {
1268 return err
1269 }
1270
1271 t.Issue = string(sval)
1272 }
1273 // t.State (string) (string)
1274 case "state":
1275
1276 {
1277 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1278 if err != nil {
1279 return err
1280 }
1281
1282 t.State = string(sval)
1283 }
1284
1285 default:
1286 // Field doesn't exist on this type, so ignore it
1287 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1288 return err
1289 }
1290 }
1291 }
1292
1293 return nil
1294}
1295func (t *RepoIssue) MarshalCBOR(w io.Writer) error {
1296 if t == nil {
1297 _, err := w.Write(cbg.CborNull)
1298 return err
1299 }
1300
1301 cw := cbg.NewCborWriter(w)
1302 fieldCount := 7
1303
1304 if t.Body == nil {
1305 fieldCount--
1306 }
1307
1308 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1309 return err
1310 }
1311
1312 // t.Body (string) (string)
1313 if t.Body != nil {
1314
1315 if len("body") > 1000000 {
1316 return xerrors.Errorf("Value in field \"body\" was too long")
1317 }
1318
1319 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
1320 return err
1321 }
1322 if _, err := cw.WriteString(string("body")); err != nil {
1323 return err
1324 }
1325
1326 if t.Body == nil {
1327 if _, err := cw.Write(cbg.CborNull); err != nil {
1328 return err
1329 }
1330 } else {
1331 if len(*t.Body) > 1000000 {
1332 return xerrors.Errorf("Value in field t.Body was too long")
1333 }
1334
1335 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
1336 return err
1337 }
1338 if _, err := cw.WriteString(string(*t.Body)); err != nil {
1339 return err
1340 }
1341 }
1342 }
1343
1344 // t.Repo (string) (string)
1345 if len("repo") > 1000000 {
1346 return xerrors.Errorf("Value in field \"repo\" was too long")
1347 }
1348
1349 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
1350 return err
1351 }
1352 if _, err := cw.WriteString(string("repo")); err != nil {
1353 return err
1354 }
1355
1356 if len(t.Repo) > 1000000 {
1357 return xerrors.Errorf("Value in field t.Repo was too long")
1358 }
1359
1360 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
1361 return err
1362 }
1363 if _, err := cw.WriteString(string(t.Repo)); err != nil {
1364 return err
1365 }
1366
1367 // t.LexiconTypeID (string) (string)
1368 if len("$type") > 1000000 {
1369 return xerrors.Errorf("Value in field \"$type\" was too long")
1370 }
1371
1372 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
1373 return err
1374 }
1375 if _, err := cw.WriteString(string("$type")); err != nil {
1376 return err
1377 }
1378
1379 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil {
1380 return err
1381 }
1382 if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil {
1383 return err
1384 }
1385
1386 // t.Owner (string) (string)
1387 if len("owner") > 1000000 {
1388 return xerrors.Errorf("Value in field \"owner\" was too long")
1389 }
1390
1391 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
1392 return err
1393 }
1394 if _, err := cw.WriteString(string("owner")); err != nil {
1395 return err
1396 }
1397
1398 if len(t.Owner) > 1000000 {
1399 return xerrors.Errorf("Value in field t.Owner was too long")
1400 }
1401
1402 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {
1403 return err
1404 }
1405 if _, err := cw.WriteString(string(t.Owner)); err != nil {
1406 return err
1407 }
1408
1409 // t.Title (string) (string)
1410 if len("title") > 1000000 {
1411 return xerrors.Errorf("Value in field \"title\" was too long")
1412 }
1413
1414 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
1415 return err
1416 }
1417 if _, err := cw.WriteString(string("title")); err != nil {
1418 return err
1419 }
1420
1421 if len(t.Title) > 1000000 {
1422 return xerrors.Errorf("Value in field t.Title was too long")
1423 }
1424
1425 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
1426 return err
1427 }
1428 if _, err := cw.WriteString(string(t.Title)); err != nil {
1429 return err
1430 }
1431
1432 // t.IssueId (int64) (int64)
1433 if len("issueId") > 1000000 {
1434 return xerrors.Errorf("Value in field \"issueId\" was too long")
1435 }
1436
1437 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issueId"))); err != nil {
1438 return err
1439 }
1440 if _, err := cw.WriteString(string("issueId")); err != nil {
1441 return err
1442 }
1443
1444 if t.IssueId >= 0 {
1445 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.IssueId)); err != nil {
1446 return err
1447 }
1448 } else {
1449 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.IssueId-1)); err != nil {
1450 return err
1451 }
1452 }
1453
1454 // t.CreatedAt (string) (string)
1455 if len("createdAt") > 1000000 {
1456 return xerrors.Errorf("Value in field \"createdAt\" was too long")
1457 }
1458
1459 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
1460 return err
1461 }
1462 if _, err := cw.WriteString(string("createdAt")); err != nil {
1463 return err
1464 }
1465
1466 if len(t.CreatedAt) > 1000000 {
1467 return xerrors.Errorf("Value in field t.CreatedAt was too long")
1468 }
1469
1470 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
1471 return err
1472 }
1473 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
1474 return err
1475 }
1476 return nil
1477}
1478
1479func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) {
1480 *t = RepoIssue{}
1481
1482 cr := cbg.NewCborReader(r)
1483
1484 maj, extra, err := cr.ReadHeader()
1485 if err != nil {
1486 return err
1487 }
1488 defer func() {
1489 if err == io.EOF {
1490 err = io.ErrUnexpectedEOF
1491 }
1492 }()
1493
1494 if maj != cbg.MajMap {
1495 return fmt.Errorf("cbor input should be of type map")
1496 }
1497
1498 if extra > cbg.MaxLength {
1499 return fmt.Errorf("RepoIssue: map struct too large (%d)", extra)
1500 }
1501
1502 n := extra
1503
1504 nameBuf := make([]byte, 9)
1505 for i := uint64(0); i < n; i++ {
1506 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1507 if err != nil {
1508 return err
1509 }
1510
1511 if !ok {
1512 // Field doesn't exist on this type, so ignore it
1513 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1514 return err
1515 }
1516 continue
1517 }
1518
1519 switch string(nameBuf[:nameLen]) {
1520 // t.Body (string) (string)
1521 case "body":
1522
1523 {
1524 b, err := cr.ReadByte()
1525 if err != nil {
1526 return err
1527 }
1528 if b != cbg.CborNull[0] {
1529 if err := cr.UnreadByte(); err != nil {
1530 return err
1531 }
1532
1533 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1534 if err != nil {
1535 return err
1536 }
1537
1538 t.Body = (*string)(&sval)
1539 }
1540 }
1541 // t.Repo (string) (string)
1542 case "repo":
1543
1544 {
1545 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1546 if err != nil {
1547 return err
1548 }
1549
1550 t.Repo = string(sval)
1551 }
1552 // t.LexiconTypeID (string) (string)
1553 case "$type":
1554
1555 {
1556 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1557 if err != nil {
1558 return err
1559 }
1560
1561 t.LexiconTypeID = string(sval)
1562 }
1563 // t.Owner (string) (string)
1564 case "owner":
1565
1566 {
1567 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1568 if err != nil {
1569 return err
1570 }
1571
1572 t.Owner = string(sval)
1573 }
1574 // t.Title (string) (string)
1575 case "title":
1576
1577 {
1578 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1579 if err != nil {
1580 return err
1581 }
1582
1583 t.Title = string(sval)
1584 }
1585 // t.IssueId (int64) (int64)
1586 case "issueId":
1587 {
1588 maj, extra, err := cr.ReadHeader()
1589 if err != nil {
1590 return err
1591 }
1592 var extraI int64
1593 switch maj {
1594 case cbg.MajUnsignedInt:
1595 extraI = int64(extra)
1596 if extraI < 0 {
1597 return fmt.Errorf("int64 positive overflow")
1598 }
1599 case cbg.MajNegativeInt:
1600 extraI = int64(extra)
1601 if extraI < 0 {
1602 return fmt.Errorf("int64 negative overflow")
1603 }
1604 extraI = -1 - extraI
1605 default:
1606 return fmt.Errorf("wrong type for int64 field: %d", maj)
1607 }
1608
1609 t.IssueId = int64(extraI)
1610 }
1611 // t.CreatedAt (string) (string)
1612 case "createdAt":
1613
1614 {
1615 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1616 if err != nil {
1617 return err
1618 }
1619
1620 t.CreatedAt = string(sval)
1621 }
1622
1623 default:
1624 // Field doesn't exist on this type, so ignore it
1625 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1626 return err
1627 }
1628 }
1629 }
1630
1631 return nil
1632}
1633func (t *Repo) MarshalCBOR(w io.Writer) error {
1634 if t == nil {
1635 _, err := w.Write(cbg.CborNull)
1636 return err
1637 }
1638
1639 cw := cbg.NewCborWriter(w)
1640 fieldCount := 7
1641
1642 if t.Description == nil {
1643 fieldCount--
1644 }
1645
1646 if t.Source == nil {
1647 fieldCount--
1648 }
1649
1650 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1651 return err
1652 }
1653
1654 // t.Knot (string) (string)
1655 if len("knot") > 1000000 {
1656 return xerrors.Errorf("Value in field \"knot\" was too long")
1657 }
1658
1659 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
1660 return err
1661 }
1662 if _, err := cw.WriteString(string("knot")); err != nil {
1663 return err
1664 }
1665
1666 if len(t.Knot) > 1000000 {
1667 return xerrors.Errorf("Value in field t.Knot was too long")
1668 }
1669
1670 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
1671 return err
1672 }
1673 if _, err := cw.WriteString(string(t.Knot)); err != nil {
1674 return err
1675 }
1676
1677 // t.Name (string) (string)
1678 if len("name") > 1000000 {
1679 return xerrors.Errorf("Value in field \"name\" was too long")
1680 }
1681
1682 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
1683 return err
1684 }
1685 if _, err := cw.WriteString(string("name")); err != nil {
1686 return err
1687 }
1688
1689 if len(t.Name) > 1000000 {
1690 return xerrors.Errorf("Value in field t.Name was too long")
1691 }
1692
1693 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
1694 return err
1695 }
1696 if _, err := cw.WriteString(string(t.Name)); err != nil {
1697 return err
1698 }
1699
1700 // t.LexiconTypeID (string) (string)
1701 if len("$type") > 1000000 {
1702 return xerrors.Errorf("Value in field \"$type\" was too long")
1703 }
1704
1705 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
1706 return err
1707 }
1708 if _, err := cw.WriteString(string("$type")); err != nil {
1709 return err
1710 }
1711
1712 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil {
1713 return err
1714 }
1715 if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil {
1716 return err
1717 }
1718
1719 // t.Owner (string) (string)
1720 if len("owner") > 1000000 {
1721 return xerrors.Errorf("Value in field \"owner\" was too long")
1722 }
1723
1724 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
1725 return err
1726 }
1727 if _, err := cw.WriteString(string("owner")); err != nil {
1728 return err
1729 }
1730
1731 if len(t.Owner) > 1000000 {
1732 return xerrors.Errorf("Value in field t.Owner was too long")
1733 }
1734
1735 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {
1736 return err
1737 }
1738 if _, err := cw.WriteString(string(t.Owner)); err != nil {
1739 return err
1740 }
1741
1742 // t.Source (string) (string)
1743 if t.Source != nil {
1744
1745 if len("source") > 1000000 {
1746 return xerrors.Errorf("Value in field \"source\" was too long")
1747 }
1748
1749 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
1750 return err
1751 }
1752 if _, err := cw.WriteString(string("source")); err != nil {
1753 return err
1754 }
1755
1756 if t.Source == nil {
1757 if _, err := cw.Write(cbg.CborNull); err != nil {
1758 return err
1759 }
1760 } else {
1761 if len(*t.Source) > 1000000 {
1762 return xerrors.Errorf("Value in field t.Source was too long")
1763 }
1764
1765 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil {
1766 return err
1767 }
1768 if _, err := cw.WriteString(string(*t.Source)); err != nil {
1769 return err
1770 }
1771 }
1772 }
1773
1774 // t.CreatedAt (string) (string)
1775 if len("createdAt") > 1000000 {
1776 return xerrors.Errorf("Value in field \"createdAt\" was too long")
1777 }
1778
1779 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
1780 return err
1781 }
1782 if _, err := cw.WriteString(string("createdAt")); err != nil {
1783 return err
1784 }
1785
1786 if len(t.CreatedAt) > 1000000 {
1787 return xerrors.Errorf("Value in field t.CreatedAt was too long")
1788 }
1789
1790 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
1791 return err
1792 }
1793 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
1794 return err
1795 }
1796
1797 // t.Description (string) (string)
1798 if t.Description != nil {
1799
1800 if len("description") > 1000000 {
1801 return xerrors.Errorf("Value in field \"description\" was too long")
1802 }
1803
1804 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
1805 return err
1806 }
1807 if _, err := cw.WriteString(string("description")); err != nil {
1808 return err
1809 }
1810
1811 if t.Description == nil {
1812 if _, err := cw.Write(cbg.CborNull); err != nil {
1813 return err
1814 }
1815 } else {
1816 if len(*t.Description) > 1000000 {
1817 return xerrors.Errorf("Value in field t.Description was too long")
1818 }
1819
1820 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
1821 return err
1822 }
1823 if _, err := cw.WriteString(string(*t.Description)); err != nil {
1824 return err
1825 }
1826 }
1827 }
1828 return nil
1829}
1830
1831func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) {
1832 *t = Repo{}
1833
1834 cr := cbg.NewCborReader(r)
1835
1836 maj, extra, err := cr.ReadHeader()
1837 if err != nil {
1838 return err
1839 }
1840 defer func() {
1841 if err == io.EOF {
1842 err = io.ErrUnexpectedEOF
1843 }
1844 }()
1845
1846 if maj != cbg.MajMap {
1847 return fmt.Errorf("cbor input should be of type map")
1848 }
1849
1850 if extra > cbg.MaxLength {
1851 return fmt.Errorf("Repo: map struct too large (%d)", extra)
1852 }
1853
1854 n := extra
1855
1856 nameBuf := make([]byte, 11)
1857 for i := uint64(0); i < n; i++ {
1858 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1859 if err != nil {
1860 return err
1861 }
1862
1863 if !ok {
1864 // Field doesn't exist on this type, so ignore it
1865 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1866 return err
1867 }
1868 continue
1869 }
1870
1871 switch string(nameBuf[:nameLen]) {
1872 // t.Knot (string) (string)
1873 case "knot":
1874
1875 {
1876 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1877 if err != nil {
1878 return err
1879 }
1880
1881 t.Knot = string(sval)
1882 }
1883 // t.Name (string) (string)
1884 case "name":
1885
1886 {
1887 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1888 if err != nil {
1889 return err
1890 }
1891
1892 t.Name = string(sval)
1893 }
1894 // t.LexiconTypeID (string) (string)
1895 case "$type":
1896
1897 {
1898 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1899 if err != nil {
1900 return err
1901 }
1902
1903 t.LexiconTypeID = string(sval)
1904 }
1905 // t.Owner (string) (string)
1906 case "owner":
1907
1908 {
1909 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1910 if err != nil {
1911 return err
1912 }
1913
1914 t.Owner = string(sval)
1915 }
1916 // t.Source (string) (string)
1917 case "source":
1918
1919 {
1920 b, err := cr.ReadByte()
1921 if err != nil {
1922 return err
1923 }
1924 if b != cbg.CborNull[0] {
1925 if err := cr.UnreadByte(); err != nil {
1926 return err
1927 }
1928
1929 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1930 if err != nil {
1931 return err
1932 }
1933
1934 t.Source = (*string)(&sval)
1935 }
1936 }
1937 // t.CreatedAt (string) (string)
1938 case "createdAt":
1939
1940 {
1941 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1942 if err != nil {
1943 return err
1944 }
1945
1946 t.CreatedAt = string(sval)
1947 }
1948 // t.Description (string) (string)
1949 case "description":
1950
1951 {
1952 b, err := cr.ReadByte()
1953 if err != nil {
1954 return err
1955 }
1956 if b != cbg.CborNull[0] {
1957 if err := cr.UnreadByte(); err != nil {
1958 return err
1959 }
1960
1961 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1962 if err != nil {
1963 return err
1964 }
1965
1966 t.Description = (*string)(&sval)
1967 }
1968 }
1969
1970 default:
1971 // Field doesn't exist on this type, so ignore it
1972 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1973 return err
1974 }
1975 }
1976 }
1977
1978 return nil
1979}
1980func (t *RepoPull) MarshalCBOR(w io.Writer) error {
1981 if t == nil {
1982 _, err := w.Write(cbg.CborNull)
1983 return err
1984 }
1985
1986 cw := cbg.NewCborWriter(w)
1987 fieldCount := 9
1988
1989 if t.Body == nil {
1990 fieldCount--
1991 }
1992
1993 if t.Source == nil {
1994 fieldCount--
1995 }
1996
1997 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1998 return err
1999 }
2000
2001 // t.Body (string) (string)
2002 if t.Body != nil {
2003
2004 if len("body") > 1000000 {
2005 return xerrors.Errorf("Value in field \"body\" was too long")
2006 }
2007
2008 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
2009 return err
2010 }
2011 if _, err := cw.WriteString(string("body")); err != nil {
2012 return err
2013 }
2014
2015 if t.Body == nil {
2016 if _, err := cw.Write(cbg.CborNull); err != nil {
2017 return err
2018 }
2019 } else {
2020 if len(*t.Body) > 1000000 {
2021 return xerrors.Errorf("Value in field t.Body was too long")
2022 }
2023
2024 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
2025 return err
2026 }
2027 if _, err := cw.WriteString(string(*t.Body)); err != nil {
2028 return err
2029 }
2030 }
2031 }
2032
2033 // t.LexiconTypeID (string) (string)
2034 if len("$type") > 1000000 {
2035 return xerrors.Errorf("Value in field \"$type\" was too long")
2036 }
2037
2038 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2039 return err
2040 }
2041 if _, err := cw.WriteString(string("$type")); err != nil {
2042 return err
2043 }
2044
2045 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil {
2046 return err
2047 }
2048 if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil {
2049 return err
2050 }
2051
2052 // t.Patch (string) (string)
2053 if len("patch") > 1000000 {
2054 return xerrors.Errorf("Value in field \"patch\" was too long")
2055 }
2056
2057 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil {
2058 return err
2059 }
2060 if _, err := cw.WriteString(string("patch")); err != nil {
2061 return err
2062 }
2063
2064 if len(t.Patch) > 1000000 {
2065 return xerrors.Errorf("Value in field t.Patch was too long")
2066 }
2067
2068 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Patch))); err != nil {
2069 return err
2070 }
2071 if _, err := cw.WriteString(string(t.Patch)); err != nil {
2072 return err
2073 }
2074
2075 // t.Title (string) (string)
2076 if len("title") > 1000000 {
2077 return xerrors.Errorf("Value in field \"title\" was too long")
2078 }
2079
2080 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
2081 return err
2082 }
2083 if _, err := cw.WriteString(string("title")); err != nil {
2084 return err
2085 }
2086
2087 if len(t.Title) > 1000000 {
2088 return xerrors.Errorf("Value in field t.Title was too long")
2089 }
2090
2091 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
2092 return err
2093 }
2094 if _, err := cw.WriteString(string(t.Title)); err != nil {
2095 return err
2096 }
2097
2098 // t.PullId (int64) (int64)
2099 if len("pullId") > 1000000 {
2100 return xerrors.Errorf("Value in field \"pullId\" was too long")
2101 }
2102
2103 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullId"))); err != nil {
2104 return err
2105 }
2106 if _, err := cw.WriteString(string("pullId")); err != nil {
2107 return err
2108 }
2109
2110 if t.PullId >= 0 {
2111 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.PullId)); err != nil {
2112 return err
2113 }
2114 } else {
2115 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.PullId-1)); err != nil {
2116 return err
2117 }
2118 }
2119
2120 // t.Source (tangled.RepoPull_Source) (struct)
2121 if t.Source != nil {
2122
2123 if len("source") > 1000000 {
2124 return xerrors.Errorf("Value in field \"source\" was too long")
2125 }
2126
2127 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
2128 return err
2129 }
2130 if _, err := cw.WriteString(string("source")); err != nil {
2131 return err
2132 }
2133
2134 if err := t.Source.MarshalCBOR(cw); err != nil {
2135 return err
2136 }
2137 }
2138
2139 // t.CreatedAt (string) (string)
2140 if len("createdAt") > 1000000 {
2141 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2142 }
2143
2144 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2145 return err
2146 }
2147 if _, err := cw.WriteString(string("createdAt")); err != nil {
2148 return err
2149 }
2150
2151 if len(t.CreatedAt) > 1000000 {
2152 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2153 }
2154
2155 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2156 return err
2157 }
2158 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2159 return err
2160 }
2161
2162 // t.TargetRepo (string) (string)
2163 if len("targetRepo") > 1000000 {
2164 return xerrors.Errorf("Value in field \"targetRepo\" was too long")
2165 }
2166
2167 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetRepo"))); err != nil {
2168 return err
2169 }
2170 if _, err := cw.WriteString(string("targetRepo")); err != nil {
2171 return err
2172 }
2173
2174 if len(t.TargetRepo) > 1000000 {
2175 return xerrors.Errorf("Value in field t.TargetRepo was too long")
2176 }
2177
2178 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetRepo))); err != nil {
2179 return err
2180 }
2181 if _, err := cw.WriteString(string(t.TargetRepo)); err != nil {
2182 return err
2183 }
2184
2185 // t.TargetBranch (string) (string)
2186 if len("targetBranch") > 1000000 {
2187 return xerrors.Errorf("Value in field \"targetBranch\" was too long")
2188 }
2189
2190 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil {
2191 return err
2192 }
2193 if _, err := cw.WriteString(string("targetBranch")); err != nil {
2194 return err
2195 }
2196
2197 if len(t.TargetBranch) > 1000000 {
2198 return xerrors.Errorf("Value in field t.TargetBranch was too long")
2199 }
2200
2201 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil {
2202 return err
2203 }
2204 if _, err := cw.WriteString(string(t.TargetBranch)); err != nil {
2205 return err
2206 }
2207 return nil
2208}
2209
2210func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) {
2211 *t = RepoPull{}
2212
2213 cr := cbg.NewCborReader(r)
2214
2215 maj, extra, err := cr.ReadHeader()
2216 if err != nil {
2217 return err
2218 }
2219 defer func() {
2220 if err == io.EOF {
2221 err = io.ErrUnexpectedEOF
2222 }
2223 }()
2224
2225 if maj != cbg.MajMap {
2226 return fmt.Errorf("cbor input should be of type map")
2227 }
2228
2229 if extra > cbg.MaxLength {
2230 return fmt.Errorf("RepoPull: map struct too large (%d)", extra)
2231 }
2232
2233 n := extra
2234
2235 nameBuf := make([]byte, 12)
2236 for i := uint64(0); i < n; i++ {
2237 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2238 if err != nil {
2239 return err
2240 }
2241
2242 if !ok {
2243 // Field doesn't exist on this type, so ignore it
2244 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2245 return err
2246 }
2247 continue
2248 }
2249
2250 switch string(nameBuf[:nameLen]) {
2251 // t.Body (string) (string)
2252 case "body":
2253
2254 {
2255 b, err := cr.ReadByte()
2256 if err != nil {
2257 return err
2258 }
2259 if b != cbg.CborNull[0] {
2260 if err := cr.UnreadByte(); err != nil {
2261 return err
2262 }
2263
2264 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2265 if err != nil {
2266 return err
2267 }
2268
2269 t.Body = (*string)(&sval)
2270 }
2271 }
2272 // t.LexiconTypeID (string) (string)
2273 case "$type":
2274
2275 {
2276 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2277 if err != nil {
2278 return err
2279 }
2280
2281 t.LexiconTypeID = string(sval)
2282 }
2283 // t.Patch (string) (string)
2284 case "patch":
2285
2286 {
2287 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2288 if err != nil {
2289 return err
2290 }
2291
2292 t.Patch = string(sval)
2293 }
2294 // t.Title (string) (string)
2295 case "title":
2296
2297 {
2298 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2299 if err != nil {
2300 return err
2301 }
2302
2303 t.Title = string(sval)
2304 }
2305 // t.PullId (int64) (int64)
2306 case "pullId":
2307 {
2308 maj, extra, err := cr.ReadHeader()
2309 if err != nil {
2310 return err
2311 }
2312 var extraI int64
2313 switch maj {
2314 case cbg.MajUnsignedInt:
2315 extraI = int64(extra)
2316 if extraI < 0 {
2317 return fmt.Errorf("int64 positive overflow")
2318 }
2319 case cbg.MajNegativeInt:
2320 extraI = int64(extra)
2321 if extraI < 0 {
2322 return fmt.Errorf("int64 negative overflow")
2323 }
2324 extraI = -1 - extraI
2325 default:
2326 return fmt.Errorf("wrong type for int64 field: %d", maj)
2327 }
2328
2329 t.PullId = int64(extraI)
2330 }
2331 // t.Source (tangled.RepoPull_Source) (struct)
2332 case "source":
2333
2334 {
2335
2336 b, err := cr.ReadByte()
2337 if err != nil {
2338 return err
2339 }
2340 if b != cbg.CborNull[0] {
2341 if err := cr.UnreadByte(); err != nil {
2342 return err
2343 }
2344 t.Source = new(RepoPull_Source)
2345 if err := t.Source.UnmarshalCBOR(cr); err != nil {
2346 return xerrors.Errorf("unmarshaling t.Source pointer: %w", err)
2347 }
2348 }
2349
2350 }
2351 // t.CreatedAt (string) (string)
2352 case "createdAt":
2353
2354 {
2355 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2356 if err != nil {
2357 return err
2358 }
2359
2360 t.CreatedAt = string(sval)
2361 }
2362 // t.TargetRepo (string) (string)
2363 case "targetRepo":
2364
2365 {
2366 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2367 if err != nil {
2368 return err
2369 }
2370
2371 t.TargetRepo = string(sval)
2372 }
2373 // t.TargetBranch (string) (string)
2374 case "targetBranch":
2375
2376 {
2377 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2378 if err != nil {
2379 return err
2380 }
2381
2382 t.TargetBranch = string(sval)
2383 }
2384
2385 default:
2386 // Field doesn't exist on this type, so ignore it
2387 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2388 return err
2389 }
2390 }
2391 }
2392
2393 return nil
2394}
2395func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error {
2396 if t == nil {
2397 _, err := w.Write(cbg.CborNull)
2398 return err
2399 }
2400
2401 cw := cbg.NewCborWriter(w)
2402 fieldCount := 2
2403
2404 if t.Repo == nil {
2405 fieldCount--
2406 }
2407
2408 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2409 return err
2410 }
2411
2412 // t.Repo (string) (string)
2413 if t.Repo != nil {
2414
2415 if len("repo") > 1000000 {
2416 return xerrors.Errorf("Value in field \"repo\" was too long")
2417 }
2418
2419 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
2420 return err
2421 }
2422 if _, err := cw.WriteString(string("repo")); err != nil {
2423 return err
2424 }
2425
2426 if t.Repo == nil {
2427 if _, err := cw.Write(cbg.CborNull); err != nil {
2428 return err
2429 }
2430 } else {
2431 if len(*t.Repo) > 1000000 {
2432 return xerrors.Errorf("Value in field t.Repo was too long")
2433 }
2434
2435 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
2436 return err
2437 }
2438 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
2439 return err
2440 }
2441 }
2442 }
2443
2444 // t.Branch (string) (string)
2445 if len("branch") > 1000000 {
2446 return xerrors.Errorf("Value in field \"branch\" was too long")
2447 }
2448
2449 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
2450 return err
2451 }
2452 if _, err := cw.WriteString(string("branch")); err != nil {
2453 return err
2454 }
2455
2456 if len(t.Branch) > 1000000 {
2457 return xerrors.Errorf("Value in field t.Branch was too long")
2458 }
2459
2460 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
2461 return err
2462 }
2463 if _, err := cw.WriteString(string(t.Branch)); err != nil {
2464 return err
2465 }
2466 return nil
2467}
2468
2469func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) {
2470 *t = RepoPull_Source{}
2471
2472 cr := cbg.NewCborReader(r)
2473
2474 maj, extra, err := cr.ReadHeader()
2475 if err != nil {
2476 return err
2477 }
2478 defer func() {
2479 if err == io.EOF {
2480 err = io.ErrUnexpectedEOF
2481 }
2482 }()
2483
2484 if maj != cbg.MajMap {
2485 return fmt.Errorf("cbor input should be of type map")
2486 }
2487
2488 if extra > cbg.MaxLength {
2489 return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra)
2490 }
2491
2492 n := extra
2493
2494 nameBuf := make([]byte, 6)
2495 for i := uint64(0); i < n; i++ {
2496 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2497 if err != nil {
2498 return err
2499 }
2500
2501 if !ok {
2502 // Field doesn't exist on this type, so ignore it
2503 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2504 return err
2505 }
2506 continue
2507 }
2508
2509 switch string(nameBuf[:nameLen]) {
2510 // t.Repo (string) (string)
2511 case "repo":
2512
2513 {
2514 b, err := cr.ReadByte()
2515 if err != nil {
2516 return err
2517 }
2518 if b != cbg.CborNull[0] {
2519 if err := cr.UnreadByte(); err != nil {
2520 return err
2521 }
2522
2523 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2524 if err != nil {
2525 return err
2526 }
2527
2528 t.Repo = (*string)(&sval)
2529 }
2530 }
2531 // t.Branch (string) (string)
2532 case "branch":
2533
2534 {
2535 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2536 if err != nil {
2537 return err
2538 }
2539
2540 t.Branch = string(sval)
2541 }
2542
2543 default:
2544 // Field doesn't exist on this type, so ignore it
2545 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2546 return err
2547 }
2548 }
2549 }
2550
2551 return nil
2552}
2553func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error {
2554 if t == nil {
2555 _, err := w.Write(cbg.CborNull)
2556 return err
2557 }
2558
2559 cw := cbg.NewCborWriter(w)
2560
2561 if _, err := cw.Write([]byte{163}); err != nil {
2562 return err
2563 }
2564
2565 // t.Pull (string) (string)
2566 if len("pull") > 1000000 {
2567 return xerrors.Errorf("Value in field \"pull\" was too long")
2568 }
2569
2570 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
2571 return err
2572 }
2573 if _, err := cw.WriteString(string("pull")); err != nil {
2574 return err
2575 }
2576
2577 if len(t.Pull) > 1000000 {
2578 return xerrors.Errorf("Value in field t.Pull was too long")
2579 }
2580
2581 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
2582 return err
2583 }
2584 if _, err := cw.WriteString(string(t.Pull)); err != nil {
2585 return err
2586 }
2587
2588 // t.LexiconTypeID (string) (string)
2589 if len("$type") > 1000000 {
2590 return xerrors.Errorf("Value in field \"$type\" was too long")
2591 }
2592
2593 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2594 return err
2595 }
2596 if _, err := cw.WriteString(string("$type")); err != nil {
2597 return err
2598 }
2599
2600 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil {
2601 return err
2602 }
2603 if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil {
2604 return err
2605 }
2606
2607 // t.Status (string) (string)
2608 if len("status") > 1000000 {
2609 return xerrors.Errorf("Value in field \"status\" was too long")
2610 }
2611
2612 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
2613 return err
2614 }
2615 if _, err := cw.WriteString(string("status")); err != nil {
2616 return err
2617 }
2618
2619 if len(t.Status) > 1000000 {
2620 return xerrors.Errorf("Value in field t.Status was too long")
2621 }
2622
2623 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
2624 return err
2625 }
2626 if _, err := cw.WriteString(string(t.Status)); err != nil {
2627 return err
2628 }
2629 return nil
2630}
2631
2632func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) {
2633 *t = RepoPullStatus{}
2634
2635 cr := cbg.NewCborReader(r)
2636
2637 maj, extra, err := cr.ReadHeader()
2638 if err != nil {
2639 return err
2640 }
2641 defer func() {
2642 if err == io.EOF {
2643 err = io.ErrUnexpectedEOF
2644 }
2645 }()
2646
2647 if maj != cbg.MajMap {
2648 return fmt.Errorf("cbor input should be of type map")
2649 }
2650
2651 if extra > cbg.MaxLength {
2652 return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra)
2653 }
2654
2655 n := extra
2656
2657 nameBuf := make([]byte, 6)
2658 for i := uint64(0); i < n; i++ {
2659 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2660 if err != nil {
2661 return err
2662 }
2663
2664 if !ok {
2665 // Field doesn't exist on this type, so ignore it
2666 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2667 return err
2668 }
2669 continue
2670 }
2671
2672 switch string(nameBuf[:nameLen]) {
2673 // t.Pull (string) (string)
2674 case "pull":
2675
2676 {
2677 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2678 if err != nil {
2679 return err
2680 }
2681
2682 t.Pull = string(sval)
2683 }
2684 // t.LexiconTypeID (string) (string)
2685 case "$type":
2686
2687 {
2688 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2689 if err != nil {
2690 return err
2691 }
2692
2693 t.LexiconTypeID = string(sval)
2694 }
2695 // t.Status (string) (string)
2696 case "status":
2697
2698 {
2699 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2700 if err != nil {
2701 return err
2702 }
2703
2704 t.Status = string(sval)
2705 }
2706
2707 default:
2708 // Field doesn't exist on this type, so ignore it
2709 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2710 return err
2711 }
2712 }
2713 }
2714
2715 return nil
2716}
2717func (t *RepoPullComment) MarshalCBOR(w io.Writer) error {
2718 if t == nil {
2719 _, err := w.Write(cbg.CborNull)
2720 return err
2721 }
2722
2723 cw := cbg.NewCborWriter(w)
2724 fieldCount := 7
2725
2726 if t.CommentId == nil {
2727 fieldCount--
2728 }
2729
2730 if t.Owner == nil {
2731 fieldCount--
2732 }
2733
2734 if t.Repo == nil {
2735 fieldCount--
2736 }
2737
2738 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2739 return err
2740 }
2741
2742 // t.Body (string) (string)
2743 if len("body") > 1000000 {
2744 return xerrors.Errorf("Value in field \"body\" was too long")
2745 }
2746
2747 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
2748 return err
2749 }
2750 if _, err := cw.WriteString(string("body")); err != nil {
2751 return err
2752 }
2753
2754 if len(t.Body) > 1000000 {
2755 return xerrors.Errorf("Value in field t.Body was too long")
2756 }
2757
2758 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
2759 return err
2760 }
2761 if _, err := cw.WriteString(string(t.Body)); err != nil {
2762 return err
2763 }
2764
2765 // t.Pull (string) (string)
2766 if len("pull") > 1000000 {
2767 return xerrors.Errorf("Value in field \"pull\" was too long")
2768 }
2769
2770 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
2771 return err
2772 }
2773 if _, err := cw.WriteString(string("pull")); err != nil {
2774 return err
2775 }
2776
2777 if len(t.Pull) > 1000000 {
2778 return xerrors.Errorf("Value in field t.Pull was too long")
2779 }
2780
2781 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
2782 return err
2783 }
2784 if _, err := cw.WriteString(string(t.Pull)); err != nil {
2785 return err
2786 }
2787
2788 // t.Repo (string) (string)
2789 if t.Repo != nil {
2790
2791 if len("repo") > 1000000 {
2792 return xerrors.Errorf("Value in field \"repo\" was too long")
2793 }
2794
2795 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
2796 return err
2797 }
2798 if _, err := cw.WriteString(string("repo")); err != nil {
2799 return err
2800 }
2801
2802 if t.Repo == nil {
2803 if _, err := cw.Write(cbg.CborNull); err != nil {
2804 return err
2805 }
2806 } else {
2807 if len(*t.Repo) > 1000000 {
2808 return xerrors.Errorf("Value in field t.Repo was too long")
2809 }
2810
2811 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
2812 return err
2813 }
2814 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
2815 return err
2816 }
2817 }
2818 }
2819
2820 // t.LexiconTypeID (string) (string)
2821 if len("$type") > 1000000 {
2822 return xerrors.Errorf("Value in field \"$type\" was too long")
2823 }
2824
2825 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2826 return err
2827 }
2828 if _, err := cw.WriteString(string("$type")); err != nil {
2829 return err
2830 }
2831
2832 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.comment"))); err != nil {
2833 return err
2834 }
2835 if _, err := cw.WriteString(string("sh.tangled.repo.pull.comment")); err != nil {
2836 return err
2837 }
2838
2839 // t.Owner (string) (string)
2840 if t.Owner != nil {
2841
2842 if len("owner") > 1000000 {
2843 return xerrors.Errorf("Value in field \"owner\" was too long")
2844 }
2845
2846 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
2847 return err
2848 }
2849 if _, err := cw.WriteString(string("owner")); err != nil {
2850 return err
2851 }
2852
2853 if t.Owner == nil {
2854 if _, err := cw.Write(cbg.CborNull); err != nil {
2855 return err
2856 }
2857 } else {
2858 if len(*t.Owner) > 1000000 {
2859 return xerrors.Errorf("Value in field t.Owner was too long")
2860 }
2861
2862 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Owner))); err != nil {
2863 return err
2864 }
2865 if _, err := cw.WriteString(string(*t.Owner)); err != nil {
2866 return err
2867 }
2868 }
2869 }
2870
2871 // t.CommentId (int64) (int64)
2872 if t.CommentId != nil {
2873
2874 if len("commentId") > 1000000 {
2875 return xerrors.Errorf("Value in field \"commentId\" was too long")
2876 }
2877
2878 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commentId"))); err != nil {
2879 return err
2880 }
2881 if _, err := cw.WriteString(string("commentId")); err != nil {
2882 return err
2883 }
2884
2885 if t.CommentId == nil {
2886 if _, err := cw.Write(cbg.CborNull); err != nil {
2887 return err
2888 }
2889 } else {
2890 if *t.CommentId >= 0 {
2891 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.CommentId)); err != nil {
2892 return err
2893 }
2894 } else {
2895 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.CommentId-1)); err != nil {
2896 return err
2897 }
2898 }
2899 }
2900
2901 }
2902
2903 // t.CreatedAt (string) (string)
2904 if len("createdAt") > 1000000 {
2905 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2906 }
2907
2908 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2909 return err
2910 }
2911 if _, err := cw.WriteString(string("createdAt")); err != nil {
2912 return err
2913 }
2914
2915 if len(t.CreatedAt) > 1000000 {
2916 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2917 }
2918
2919 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2920 return err
2921 }
2922 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2923 return err
2924 }
2925 return nil
2926}
2927
2928func (t *RepoPullComment) UnmarshalCBOR(r io.Reader) (err error) {
2929 *t = RepoPullComment{}
2930
2931 cr := cbg.NewCborReader(r)
2932
2933 maj, extra, err := cr.ReadHeader()
2934 if err != nil {
2935 return err
2936 }
2937 defer func() {
2938 if err == io.EOF {
2939 err = io.ErrUnexpectedEOF
2940 }
2941 }()
2942
2943 if maj != cbg.MajMap {
2944 return fmt.Errorf("cbor input should be of type map")
2945 }
2946
2947 if extra > cbg.MaxLength {
2948 return fmt.Errorf("RepoPullComment: map struct too large (%d)", extra)
2949 }
2950
2951 n := extra
2952
2953 nameBuf := make([]byte, 9)
2954 for i := uint64(0); i < n; i++ {
2955 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2956 if err != nil {
2957 return err
2958 }
2959
2960 if !ok {
2961 // Field doesn't exist on this type, so ignore it
2962 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2963 return err
2964 }
2965 continue
2966 }
2967
2968 switch string(nameBuf[:nameLen]) {
2969 // t.Body (string) (string)
2970 case "body":
2971
2972 {
2973 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2974 if err != nil {
2975 return err
2976 }
2977
2978 t.Body = string(sval)
2979 }
2980 // t.Pull (string) (string)
2981 case "pull":
2982
2983 {
2984 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2985 if err != nil {
2986 return err
2987 }
2988
2989 t.Pull = string(sval)
2990 }
2991 // t.Repo (string) (string)
2992 case "repo":
2993
2994 {
2995 b, err := cr.ReadByte()
2996 if err != nil {
2997 return err
2998 }
2999 if b != cbg.CborNull[0] {
3000 if err := cr.UnreadByte(); err != nil {
3001 return err
3002 }
3003
3004 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3005 if err != nil {
3006 return err
3007 }
3008
3009 t.Repo = (*string)(&sval)
3010 }
3011 }
3012 // t.LexiconTypeID (string) (string)
3013 case "$type":
3014
3015 {
3016 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3017 if err != nil {
3018 return err
3019 }
3020
3021 t.LexiconTypeID = string(sval)
3022 }
3023 // t.Owner (string) (string)
3024 case "owner":
3025
3026 {
3027 b, err := cr.ReadByte()
3028 if err != nil {
3029 return err
3030 }
3031 if b != cbg.CborNull[0] {
3032 if err := cr.UnreadByte(); err != nil {
3033 return err
3034 }
3035
3036 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3037 if err != nil {
3038 return err
3039 }
3040
3041 t.Owner = (*string)(&sval)
3042 }
3043 }
3044 // t.CommentId (int64) (int64)
3045 case "commentId":
3046 {
3047
3048 b, err := cr.ReadByte()
3049 if err != nil {
3050 return err
3051 }
3052 if b != cbg.CborNull[0] {
3053 if err := cr.UnreadByte(); err != nil {
3054 return err
3055 }
3056 maj, extra, err := cr.ReadHeader()
3057 if err != nil {
3058 return err
3059 }
3060 var extraI int64
3061 switch maj {
3062 case cbg.MajUnsignedInt:
3063 extraI = int64(extra)
3064 if extraI < 0 {
3065 return fmt.Errorf("int64 positive overflow")
3066 }
3067 case cbg.MajNegativeInt:
3068 extraI = int64(extra)
3069 if extraI < 0 {
3070 return fmt.Errorf("int64 negative overflow")
3071 }
3072 extraI = -1 - extraI
3073 default:
3074 return fmt.Errorf("wrong type for int64 field: %d", maj)
3075 }
3076
3077 t.CommentId = (*int64)(&extraI)
3078 }
3079 }
3080 // t.CreatedAt (string) (string)
3081 case "createdAt":
3082
3083 {
3084 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3085 if err != nil {
3086 return err
3087 }
3088
3089 t.CreatedAt = string(sval)
3090 }
3091
3092 default:
3093 // Field doesn't exist on this type, so ignore it
3094 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3095 return err
3096 }
3097 }
3098 }
3099
3100 return nil
3101}
3102func (t *RepoArtifact) MarshalCBOR(w io.Writer) error {
3103 if t == nil {
3104 _, err := w.Write(cbg.CborNull)
3105 return err
3106 }
3107
3108 cw := cbg.NewCborWriter(w)
3109 fieldCount := 6
3110
3111 if t.Tag == nil {
3112 fieldCount--
3113 }
3114
3115 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3116 return err
3117 }
3118
3119 // t.Tag (util.LexBytes) (slice)
3120 if t.Tag != nil {
3121
3122 if len("tag") > 1000000 {
3123 return xerrors.Errorf("Value in field \"tag\" was too long")
3124 }
3125
3126 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tag"))); err != nil {
3127 return err
3128 }
3129 if _, err := cw.WriteString(string("tag")); err != nil {
3130 return err
3131 }
3132
3133 if len(t.Tag) > 2097152 {
3134 return xerrors.Errorf("Byte array in field t.Tag was too long")
3135 }
3136
3137 if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Tag))); err != nil {
3138 return err
3139 }
3140
3141 if _, err := cw.Write(t.Tag); err != nil {
3142 return err
3143 }
3144
3145 }
3146
3147 // t.Name (string) (string)
3148 if len("name") > 1000000 {
3149 return xerrors.Errorf("Value in field \"name\" was too long")
3150 }
3151
3152 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
3153 return err
3154 }
3155 if _, err := cw.WriteString(string("name")); err != nil {
3156 return err
3157 }
3158
3159 if len(t.Name) > 1000000 {
3160 return xerrors.Errorf("Value in field t.Name was too long")
3161 }
3162
3163 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
3164 return err
3165 }
3166 if _, err := cw.WriteString(string(t.Name)); err != nil {
3167 return err
3168 }
3169
3170 // t.Repo (string) (string)
3171 if len("repo") > 1000000 {
3172 return xerrors.Errorf("Value in field \"repo\" was too long")
3173 }
3174
3175 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
3176 return err
3177 }
3178 if _, err := cw.WriteString(string("repo")); err != nil {
3179 return err
3180 }
3181
3182 if len(t.Repo) > 1000000 {
3183 return xerrors.Errorf("Value in field t.Repo was too long")
3184 }
3185
3186 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
3187 return err
3188 }
3189 if _, err := cw.WriteString(string(t.Repo)); err != nil {
3190 return err
3191 }
3192
3193 // t.LexiconTypeID (string) (string)
3194 if len("$type") > 1000000 {
3195 return xerrors.Errorf("Value in field \"$type\" was too long")
3196 }
3197
3198 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3199 return err
3200 }
3201 if _, err := cw.WriteString(string("$type")); err != nil {
3202 return err
3203 }
3204
3205 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.artifact"))); err != nil {
3206 return err
3207 }
3208 if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil {
3209 return err
3210 }
3211
3212 // t.Artifact (util.LexBlob) (struct)
3213 if len("artifact") > 1000000 {
3214 return xerrors.Errorf("Value in field \"artifact\" was too long")
3215 }
3216
3217 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("artifact"))); err != nil {
3218 return err
3219 }
3220 if _, err := cw.WriteString(string("artifact")); err != nil {
3221 return err
3222 }
3223
3224 if err := t.Artifact.MarshalCBOR(cw); err != nil {
3225 return err
3226 }
3227
3228 // t.CreatedAt (string) (string)
3229 if len("createdAt") > 1000000 {
3230 return xerrors.Errorf("Value in field \"createdAt\" was too long")
3231 }
3232
3233 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
3234 return err
3235 }
3236 if _, err := cw.WriteString(string("createdAt")); err != nil {
3237 return err
3238 }
3239
3240 if len(t.CreatedAt) > 1000000 {
3241 return xerrors.Errorf("Value in field t.CreatedAt was too long")
3242 }
3243
3244 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
3245 return err
3246 }
3247 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
3248 return err
3249 }
3250 return nil
3251}
3252
3253func (t *RepoArtifact) UnmarshalCBOR(r io.Reader) (err error) {
3254 *t = RepoArtifact{}
3255
3256 cr := cbg.NewCborReader(r)
3257
3258 maj, extra, err := cr.ReadHeader()
3259 if err != nil {
3260 return err
3261 }
3262 defer func() {
3263 if err == io.EOF {
3264 err = io.ErrUnexpectedEOF
3265 }
3266 }()
3267
3268 if maj != cbg.MajMap {
3269 return fmt.Errorf("cbor input should be of type map")
3270 }
3271
3272 if extra > cbg.MaxLength {
3273 return fmt.Errorf("RepoArtifact: map struct too large (%d)", extra)
3274 }
3275
3276 n := extra
3277
3278 nameBuf := make([]byte, 9)
3279 for i := uint64(0); i < n; i++ {
3280 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3281 if err != nil {
3282 return err
3283 }
3284
3285 if !ok {
3286 // Field doesn't exist on this type, so ignore it
3287 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3288 return err
3289 }
3290 continue
3291 }
3292
3293 switch string(nameBuf[:nameLen]) {
3294 // t.Tag (util.LexBytes) (slice)
3295 case "tag":
3296
3297 maj, extra, err = cr.ReadHeader()
3298 if err != nil {
3299 return err
3300 }
3301
3302 if extra > 2097152 {
3303 return fmt.Errorf("t.Tag: byte array too large (%d)", extra)
3304 }
3305 if maj != cbg.MajByteString {
3306 return fmt.Errorf("expected byte array")
3307 }
3308
3309 if extra > 0 {
3310 t.Tag = make([]uint8, extra)
3311 }
3312
3313 if _, err := io.ReadFull(cr, t.Tag); err != nil {
3314 return err
3315 }
3316
3317 // t.Name (string) (string)
3318 case "name":
3319
3320 {
3321 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3322 if err != nil {
3323 return err
3324 }
3325
3326 t.Name = string(sval)
3327 }
3328 // t.Repo (string) (string)
3329 case "repo":
3330
3331 {
3332 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3333 if err != nil {
3334 return err
3335 }
3336
3337 t.Repo = string(sval)
3338 }
3339 // t.LexiconTypeID (string) (string)
3340 case "$type":
3341
3342 {
3343 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3344 if err != nil {
3345 return err
3346 }
3347
3348 t.LexiconTypeID = string(sval)
3349 }
3350 // t.Artifact (util.LexBlob) (struct)
3351 case "artifact":
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.Artifact = new(util.LexBlob)
3364 if err := t.Artifact.UnmarshalCBOR(cr); err != nil {
3365 return xerrors.Errorf("unmarshaling t.Artifact pointer: %w", err)
3366 }
3367 }
3368
3369 }
3370 // t.CreatedAt (string) (string)
3371 case "createdAt":
3372
3373 {
3374 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3375 if err != nil {
3376 return err
3377 }
3378
3379 t.CreatedAt = string(sval)
3380 }
3381
3382 default:
3383 // Field doesn't exist on this type, so ignore it
3384 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3385 return err
3386 }
3387 }
3388 }
3389
3390 return nil
3391}
3392func (t *ActorProfile) MarshalCBOR(w io.Writer) error {
3393 if t == nil {
3394 _, err := w.Write(cbg.CborNull)
3395 return err
3396 }
3397
3398 cw := cbg.NewCborWriter(w)
3399 fieldCount := 7
3400
3401 if t.Bluesky == nil {
3402 fieldCount--
3403 }
3404
3405 if t.Description == nil {
3406 fieldCount--
3407 }
3408
3409 if t.Links == nil {
3410 fieldCount--
3411 }
3412
3413 if t.Location == nil {
3414 fieldCount--
3415 }
3416
3417 if t.PinnedRepositories == nil {
3418 fieldCount--
3419 }
3420
3421 if t.Stats == nil {
3422 fieldCount--
3423 }
3424
3425 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3426 return err
3427 }
3428
3429 // t.LexiconTypeID (string) (string)
3430 if len("$type") > 1000000 {
3431 return xerrors.Errorf("Value in field \"$type\" was too long")
3432 }
3433
3434 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3435 return err
3436 }
3437 if _, err := cw.WriteString(string("$type")); err != nil {
3438 return err
3439 }
3440
3441 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.actor.profile"))); err != nil {
3442 return err
3443 }
3444 if _, err := cw.WriteString(string("sh.tangled.actor.profile")); err != nil {
3445 return err
3446 }
3447
3448 // t.Links ([]string) (slice)
3449 if t.Links != nil {
3450
3451 if len("links") > 1000000 {
3452 return xerrors.Errorf("Value in field \"links\" was too long")
3453 }
3454
3455 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("links"))); err != nil {
3456 return err
3457 }
3458 if _, err := cw.WriteString(string("links")); err != nil {
3459 return err
3460 }
3461
3462 if len(t.Links) > 8192 {
3463 return xerrors.Errorf("Slice value in field t.Links was too long")
3464 }
3465
3466 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Links))); err != nil {
3467 return err
3468 }
3469 for _, v := range t.Links {
3470 if len(v) > 1000000 {
3471 return xerrors.Errorf("Value in field v was too long")
3472 }
3473
3474 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
3475 return err
3476 }
3477 if _, err := cw.WriteString(string(v)); err != nil {
3478 return err
3479 }
3480
3481 }
3482 }
3483
3484 // t.Stats ([]string) (slice)
3485 if t.Stats != nil {
3486
3487 if len("stats") > 1000000 {
3488 return xerrors.Errorf("Value in field \"stats\" was too long")
3489 }
3490
3491 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("stats"))); err != nil {
3492 return err
3493 }
3494 if _, err := cw.WriteString(string("stats")); err != nil {
3495 return err
3496 }
3497
3498 if len(t.Stats) > 8192 {
3499 return xerrors.Errorf("Slice value in field t.Stats was too long")
3500 }
3501
3502 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Stats))); err != nil {
3503 return err
3504 }
3505 for _, v := range t.Stats {
3506 if len(v) > 1000000 {
3507 return xerrors.Errorf("Value in field v was too long")
3508 }
3509
3510 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
3511 return err
3512 }
3513 if _, err := cw.WriteString(string(v)); err != nil {
3514 return err
3515 }
3516
3517 }
3518 }
3519
3520 // t.Bluesky (bool) (bool)
3521 if t.Bluesky != nil {
3522
3523 if len("bluesky") > 1000000 {
3524 return xerrors.Errorf("Value in field \"bluesky\" was too long")
3525 }
3526
3527 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("bluesky"))); err != nil {
3528 return err
3529 }
3530 if _, err := cw.WriteString(string("bluesky")); err != nil {
3531 return err
3532 }
3533
3534 if t.Bluesky == nil {
3535 if _, err := cw.Write(cbg.CborNull); err != nil {
3536 return err
3537 }
3538 } else {
3539 if err := cbg.WriteBool(w, *t.Bluesky); err != nil {
3540 return err
3541 }
3542 }
3543 }
3544
3545 // t.Location (string) (string)
3546 if t.Location != nil {
3547
3548 if len("location") > 1000000 {
3549 return xerrors.Errorf("Value in field \"location\" was too long")
3550 }
3551
3552 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("location"))); err != nil {
3553 return err
3554 }
3555 if _, err := cw.WriteString(string("location")); err != nil {
3556 return err
3557 }
3558
3559 if t.Location == nil {
3560 if _, err := cw.Write(cbg.CborNull); err != nil {
3561 return err
3562 }
3563 } else {
3564 if len(*t.Location) > 1000000 {
3565 return xerrors.Errorf("Value in field t.Location was too long")
3566 }
3567
3568 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Location))); err != nil {
3569 return err
3570 }
3571 if _, err := cw.WriteString(string(*t.Location)); err != nil {
3572 return err
3573 }
3574 }
3575 }
3576
3577 // t.Description (string) (string)
3578 if t.Description != nil {
3579
3580 if len("description") > 1000000 {
3581 return xerrors.Errorf("Value in field \"description\" was too long")
3582 }
3583
3584 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
3585 return err
3586 }
3587 if _, err := cw.WriteString(string("description")); err != nil {
3588 return err
3589 }
3590
3591 if t.Description == nil {
3592 if _, err := cw.Write(cbg.CborNull); err != nil {
3593 return err
3594 }
3595 } else {
3596 if len(*t.Description) > 1000000 {
3597 return xerrors.Errorf("Value in field t.Description was too long")
3598 }
3599
3600 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
3601 return err
3602 }
3603 if _, err := cw.WriteString(string(*t.Description)); err != nil {
3604 return err
3605 }
3606 }
3607 }
3608
3609 // t.PinnedRepositories ([]string) (slice)
3610 if t.PinnedRepositories != nil {
3611
3612 if len("pinnedRepositories") > 1000000 {
3613 return xerrors.Errorf("Value in field \"pinnedRepositories\" was too long")
3614 }
3615
3616 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pinnedRepositories"))); err != nil {
3617 return err
3618 }
3619 if _, err := cw.WriteString(string("pinnedRepositories")); err != nil {
3620 return err
3621 }
3622
3623 if len(t.PinnedRepositories) > 8192 {
3624 return xerrors.Errorf("Slice value in field t.PinnedRepositories was too long")
3625 }
3626
3627 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.PinnedRepositories))); err != nil {
3628 return err
3629 }
3630 for _, v := range t.PinnedRepositories {
3631 if len(v) > 1000000 {
3632 return xerrors.Errorf("Value in field v was too long")
3633 }
3634
3635 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
3636 return err
3637 }
3638 if _, err := cw.WriteString(string(v)); err != nil {
3639 return err
3640 }
3641
3642 }
3643 }
3644 return nil
3645}
3646
3647func (t *ActorProfile) UnmarshalCBOR(r io.Reader) (err error) {
3648 *t = ActorProfile{}
3649
3650 cr := cbg.NewCborReader(r)
3651
3652 maj, extra, err := cr.ReadHeader()
3653 if err != nil {
3654 return err
3655 }
3656 defer func() {
3657 if err == io.EOF {
3658 err = io.ErrUnexpectedEOF
3659 }
3660 }()
3661
3662 if maj != cbg.MajMap {
3663 return fmt.Errorf("cbor input should be of type map")
3664 }
3665
3666 if extra > cbg.MaxLength {
3667 return fmt.Errorf("ActorProfile: map struct too large (%d)", extra)
3668 }
3669
3670 n := extra
3671
3672 nameBuf := make([]byte, 18)
3673 for i := uint64(0); i < n; i++ {
3674 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3675 if err != nil {
3676 return err
3677 }
3678
3679 if !ok {
3680 // Field doesn't exist on this type, so ignore it
3681 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3682 return err
3683 }
3684 continue
3685 }
3686
3687 switch string(nameBuf[:nameLen]) {
3688 // t.LexiconTypeID (string) (string)
3689 case "$type":
3690
3691 {
3692 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3693 if err != nil {
3694 return err
3695 }
3696
3697 t.LexiconTypeID = string(sval)
3698 }
3699 // t.Links ([]string) (slice)
3700 case "links":
3701
3702 maj, extra, err = cr.ReadHeader()
3703 if err != nil {
3704 return err
3705 }
3706
3707 if extra > 8192 {
3708 return fmt.Errorf("t.Links: array too large (%d)", extra)
3709 }
3710
3711 if maj != cbg.MajArray {
3712 return fmt.Errorf("expected cbor array")
3713 }
3714
3715 if extra > 0 {
3716 t.Links = make([]string, extra)
3717 }
3718
3719 for i := 0; i < int(extra); i++ {
3720 {
3721 var maj byte
3722 var extra uint64
3723 var err error
3724 _ = maj
3725 _ = extra
3726 _ = err
3727
3728 {
3729 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3730 if err != nil {
3731 return err
3732 }
3733
3734 t.Links[i] = string(sval)
3735 }
3736
3737 }
3738 }
3739 // t.Stats ([]string) (slice)
3740 case "stats":
3741
3742 maj, extra, err = cr.ReadHeader()
3743 if err != nil {
3744 return err
3745 }
3746
3747 if extra > 8192 {
3748 return fmt.Errorf("t.Stats: array too large (%d)", extra)
3749 }
3750
3751 if maj != cbg.MajArray {
3752 return fmt.Errorf("expected cbor array")
3753 }
3754
3755 if extra > 0 {
3756 t.Stats = make([]string, extra)
3757 }
3758
3759 for i := 0; i < int(extra); i++ {
3760 {
3761 var maj byte
3762 var extra uint64
3763 var err error
3764 _ = maj
3765 _ = extra
3766 _ = err
3767
3768 {
3769 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3770 if err != nil {
3771 return err
3772 }
3773
3774 t.Stats[i] = string(sval)
3775 }
3776
3777 }
3778 }
3779 // t.Bluesky (bool) (bool)
3780 case "bluesky":
3781
3782 {
3783 b, err := cr.ReadByte()
3784 if err != nil {
3785 return err
3786 }
3787 if b != cbg.CborNull[0] {
3788 if err := cr.UnreadByte(); err != nil {
3789 return err
3790 }
3791
3792 maj, extra, err = cr.ReadHeader()
3793 if err != nil {
3794 return err
3795 }
3796 if maj != cbg.MajOther {
3797 return fmt.Errorf("booleans must be major type 7")
3798 }
3799
3800 var val bool
3801 switch extra {
3802 case 20:
3803 val = false
3804 case 21:
3805 val = true
3806 default:
3807 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
3808 }
3809 t.Bluesky = &val
3810 }
3811 }
3812 // t.Location (string) (string)
3813 case "location":
3814
3815 {
3816 b, err := cr.ReadByte()
3817 if err != nil {
3818 return err
3819 }
3820 if b != cbg.CborNull[0] {
3821 if err := cr.UnreadByte(); err != nil {
3822 return err
3823 }
3824
3825 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3826 if err != nil {
3827 return err
3828 }
3829
3830 t.Location = (*string)(&sval)
3831 }
3832 }
3833 // t.Description (string) (string)
3834 case "description":
3835
3836 {
3837 b, err := cr.ReadByte()
3838 if err != nil {
3839 return err
3840 }
3841 if b != cbg.CborNull[0] {
3842 if err := cr.UnreadByte(); err != nil {
3843 return err
3844 }
3845
3846 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3847 if err != nil {
3848 return err
3849 }
3850
3851 t.Description = (*string)(&sval)
3852 }
3853 }
3854 // t.PinnedRepositories ([]string) (slice)
3855 case "pinnedRepositories":
3856
3857 maj, extra, err = cr.ReadHeader()
3858 if err != nil {
3859 return err
3860 }
3861
3862 if extra > 8192 {
3863 return fmt.Errorf("t.PinnedRepositories: array too large (%d)", extra)
3864 }
3865
3866 if maj != cbg.MajArray {
3867 return fmt.Errorf("expected cbor array")
3868 }
3869
3870 if extra > 0 {
3871 t.PinnedRepositories = make([]string, extra)
3872 }
3873
3874 for i := 0; i < int(extra); i++ {
3875 {
3876 var maj byte
3877 var extra uint64
3878 var err error
3879 _ = maj
3880 _ = extra
3881 _ = err
3882
3883 {
3884 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3885 if err != nil {
3886 return err
3887 }
3888
3889 t.PinnedRepositories[i] = string(sval)
3890 }
3891
3892 }
3893 }
3894
3895 default:
3896 // Field doesn't exist on this type, so ignore it
3897 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3898 return err
3899 }
3900 }
3901 }
3902
3903 return nil
3904}