foxgirl.engineering
forked from
tangled.org/core
fork
Configure Feed
Select the types of activity you want to include in your feed.
this repo has no description
fork
Configure Feed
Select the types of activity you want to include in your feed.
oppi.li
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.Description == nil {
3402 fieldCount--
3403 }
3404
3405 if t.Links == nil {
3406 fieldCount--
3407 }
3408
3409 if t.Location == nil {
3410 fieldCount--
3411 }
3412
3413 if t.PinnedRepositories == nil {
3414 fieldCount--
3415 }
3416
3417 if t.Stats == nil {
3418 fieldCount--
3419 }
3420
3421 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3422 return err
3423 }
3424
3425 // t.LexiconTypeID (string) (string)
3426 if len("$type") > 1000000 {
3427 return xerrors.Errorf("Value in field \"$type\" was too long")
3428 }
3429
3430 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3431 return err
3432 }
3433 if _, err := cw.WriteString(string("$type")); err != nil {
3434 return err
3435 }
3436
3437 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.actor.profile"))); err != nil {
3438 return err
3439 }
3440 if _, err := cw.WriteString(string("sh.tangled.actor.profile")); err != nil {
3441 return err
3442 }
3443
3444 // t.Links ([]string) (slice)
3445 if t.Links != nil {
3446
3447 if len("links") > 1000000 {
3448 return xerrors.Errorf("Value in field \"links\" was too long")
3449 }
3450
3451 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("links"))); err != nil {
3452 return err
3453 }
3454 if _, err := cw.WriteString(string("links")); err != nil {
3455 return err
3456 }
3457
3458 if len(t.Links) > 8192 {
3459 return xerrors.Errorf("Slice value in field t.Links was too long")
3460 }
3461
3462 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Links))); err != nil {
3463 return err
3464 }
3465 for _, v := range t.Links {
3466 if len(v) > 1000000 {
3467 return xerrors.Errorf("Value in field v was too long")
3468 }
3469
3470 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
3471 return err
3472 }
3473 if _, err := cw.WriteString(string(v)); err != nil {
3474 return err
3475 }
3476
3477 }
3478 }
3479
3480 // t.Stats ([]string) (slice)
3481 if t.Stats != nil {
3482
3483 if len("stats") > 1000000 {
3484 return xerrors.Errorf("Value in field \"stats\" was too long")
3485 }
3486
3487 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("stats"))); err != nil {
3488 return err
3489 }
3490 if _, err := cw.WriteString(string("stats")); err != nil {
3491 return err
3492 }
3493
3494 if len(t.Stats) > 8192 {
3495 return xerrors.Errorf("Slice value in field t.Stats was too long")
3496 }
3497
3498 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Stats))); err != nil {
3499 return err
3500 }
3501 for _, v := range t.Stats {
3502 if len(v) > 1000000 {
3503 return xerrors.Errorf("Value in field v was too long")
3504 }
3505
3506 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
3507 return err
3508 }
3509 if _, err := cw.WriteString(string(v)); err != nil {
3510 return err
3511 }
3512
3513 }
3514 }
3515
3516 // t.Bluesky (bool) (bool)
3517 if len("bluesky") > 1000000 {
3518 return xerrors.Errorf("Value in field \"bluesky\" was too long")
3519 }
3520
3521 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("bluesky"))); err != nil {
3522 return err
3523 }
3524 if _, err := cw.WriteString(string("bluesky")); err != nil {
3525 return err
3526 }
3527
3528 if err := cbg.WriteBool(w, t.Bluesky); err != nil {
3529 return err
3530 }
3531
3532 // t.Location (string) (string)
3533 if t.Location != nil {
3534
3535 if len("location") > 1000000 {
3536 return xerrors.Errorf("Value in field \"location\" was too long")
3537 }
3538
3539 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("location"))); err != nil {
3540 return err
3541 }
3542 if _, err := cw.WriteString(string("location")); err != nil {
3543 return err
3544 }
3545
3546 if t.Location == nil {
3547 if _, err := cw.Write(cbg.CborNull); err != nil {
3548 return err
3549 }
3550 } else {
3551 if len(*t.Location) > 1000000 {
3552 return xerrors.Errorf("Value in field t.Location was too long")
3553 }
3554
3555 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Location))); err != nil {
3556 return err
3557 }
3558 if _, err := cw.WriteString(string(*t.Location)); err != nil {
3559 return err
3560 }
3561 }
3562 }
3563
3564 // t.Description (string) (string)
3565 if t.Description != nil {
3566
3567 if len("description") > 1000000 {
3568 return xerrors.Errorf("Value in field \"description\" was too long")
3569 }
3570
3571 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
3572 return err
3573 }
3574 if _, err := cw.WriteString(string("description")); err != nil {
3575 return err
3576 }
3577
3578 if t.Description == nil {
3579 if _, err := cw.Write(cbg.CborNull); err != nil {
3580 return err
3581 }
3582 } else {
3583 if len(*t.Description) > 1000000 {
3584 return xerrors.Errorf("Value in field t.Description was too long")
3585 }
3586
3587 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
3588 return err
3589 }
3590 if _, err := cw.WriteString(string(*t.Description)); err != nil {
3591 return err
3592 }
3593 }
3594 }
3595
3596 // t.PinnedRepositories ([]string) (slice)
3597 if t.PinnedRepositories != nil {
3598
3599 if len("pinnedRepositories") > 1000000 {
3600 return xerrors.Errorf("Value in field \"pinnedRepositories\" was too long")
3601 }
3602
3603 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pinnedRepositories"))); err != nil {
3604 return err
3605 }
3606 if _, err := cw.WriteString(string("pinnedRepositories")); err != nil {
3607 return err
3608 }
3609
3610 if len(t.PinnedRepositories) > 8192 {
3611 return xerrors.Errorf("Slice value in field t.PinnedRepositories was too long")
3612 }
3613
3614 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.PinnedRepositories))); err != nil {
3615 return err
3616 }
3617 for _, v := range t.PinnedRepositories {
3618 if len(v) > 1000000 {
3619 return xerrors.Errorf("Value in field v was too long")
3620 }
3621
3622 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
3623 return err
3624 }
3625 if _, err := cw.WriteString(string(v)); err != nil {
3626 return err
3627 }
3628
3629 }
3630 }
3631 return nil
3632}
3633
3634func (t *ActorProfile) UnmarshalCBOR(r io.Reader) (err error) {
3635 *t = ActorProfile{}
3636
3637 cr := cbg.NewCborReader(r)
3638
3639 maj, extra, err := cr.ReadHeader()
3640 if err != nil {
3641 return err
3642 }
3643 defer func() {
3644 if err == io.EOF {
3645 err = io.ErrUnexpectedEOF
3646 }
3647 }()
3648
3649 if maj != cbg.MajMap {
3650 return fmt.Errorf("cbor input should be of type map")
3651 }
3652
3653 if extra > cbg.MaxLength {
3654 return fmt.Errorf("ActorProfile: map struct too large (%d)", extra)
3655 }
3656
3657 n := extra
3658
3659 nameBuf := make([]byte, 18)
3660 for i := uint64(0); i < n; i++ {
3661 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3662 if err != nil {
3663 return err
3664 }
3665
3666 if !ok {
3667 // Field doesn't exist on this type, so ignore it
3668 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3669 return err
3670 }
3671 continue
3672 }
3673
3674 switch string(nameBuf[:nameLen]) {
3675 // t.LexiconTypeID (string) (string)
3676 case "$type":
3677
3678 {
3679 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3680 if err != nil {
3681 return err
3682 }
3683
3684 t.LexiconTypeID = string(sval)
3685 }
3686 // t.Links ([]string) (slice)
3687 case "links":
3688
3689 maj, extra, err = cr.ReadHeader()
3690 if err != nil {
3691 return err
3692 }
3693
3694 if extra > 8192 {
3695 return fmt.Errorf("t.Links: array too large (%d)", extra)
3696 }
3697
3698 if maj != cbg.MajArray {
3699 return fmt.Errorf("expected cbor array")
3700 }
3701
3702 if extra > 0 {
3703 t.Links = make([]string, extra)
3704 }
3705
3706 for i := 0; i < int(extra); i++ {
3707 {
3708 var maj byte
3709 var extra uint64
3710 var err error
3711 _ = maj
3712 _ = extra
3713 _ = err
3714
3715 {
3716 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3717 if err != nil {
3718 return err
3719 }
3720
3721 t.Links[i] = string(sval)
3722 }
3723
3724 }
3725 }
3726 // t.Stats ([]string) (slice)
3727 case "stats":
3728
3729 maj, extra, err = cr.ReadHeader()
3730 if err != nil {
3731 return err
3732 }
3733
3734 if extra > 8192 {
3735 return fmt.Errorf("t.Stats: array too large (%d)", extra)
3736 }
3737
3738 if maj != cbg.MajArray {
3739 return fmt.Errorf("expected cbor array")
3740 }
3741
3742 if extra > 0 {
3743 t.Stats = make([]string, extra)
3744 }
3745
3746 for i := 0; i < int(extra); i++ {
3747 {
3748 var maj byte
3749 var extra uint64
3750 var err error
3751 _ = maj
3752 _ = extra
3753 _ = err
3754
3755 {
3756 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3757 if err != nil {
3758 return err
3759 }
3760
3761 t.Stats[i] = string(sval)
3762 }
3763
3764 }
3765 }
3766 // t.Bluesky (bool) (bool)
3767 case "bluesky":
3768
3769 maj, extra, err = cr.ReadHeader()
3770 if err != nil {
3771 return err
3772 }
3773 if maj != cbg.MajOther {
3774 return fmt.Errorf("booleans must be major type 7")
3775 }
3776 switch extra {
3777 case 20:
3778 t.Bluesky = false
3779 case 21:
3780 t.Bluesky = true
3781 default:
3782 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
3783 }
3784 // t.Location (string) (string)
3785 case "location":
3786
3787 {
3788 b, err := cr.ReadByte()
3789 if err != nil {
3790 return err
3791 }
3792 if b != cbg.CborNull[0] {
3793 if err := cr.UnreadByte(); err != nil {
3794 return err
3795 }
3796
3797 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3798 if err != nil {
3799 return err
3800 }
3801
3802 t.Location = (*string)(&sval)
3803 }
3804 }
3805 // t.Description (string) (string)
3806 case "description":
3807
3808 {
3809 b, err := cr.ReadByte()
3810 if err != nil {
3811 return err
3812 }
3813 if b != cbg.CborNull[0] {
3814 if err := cr.UnreadByte(); err != nil {
3815 return err
3816 }
3817
3818 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3819 if err != nil {
3820 return err
3821 }
3822
3823 t.Description = (*string)(&sval)
3824 }
3825 }
3826 // t.PinnedRepositories ([]string) (slice)
3827 case "pinnedRepositories":
3828
3829 maj, extra, err = cr.ReadHeader()
3830 if err != nil {
3831 return err
3832 }
3833
3834 if extra > 8192 {
3835 return fmt.Errorf("t.PinnedRepositories: array too large (%d)", extra)
3836 }
3837
3838 if maj != cbg.MajArray {
3839 return fmt.Errorf("expected cbor array")
3840 }
3841
3842 if extra > 0 {
3843 t.PinnedRepositories = make([]string, extra)
3844 }
3845
3846 for i := 0; i < int(extra); i++ {
3847 {
3848 var maj byte
3849 var extra uint64
3850 var err error
3851 _ = maj
3852 _ = extra
3853 _ = err
3854
3855 {
3856 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3857 if err != nil {
3858 return err
3859 }
3860
3861 t.PinnedRepositories[i] = string(sval)
3862 }
3863
3864 }
3865 }
3866
3867 default:
3868 // Field doesn't exist on this type, so ignore it
3869 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3870 return err
3871 }
3872 }
3873 }
3874
3875 return nil
3876}