sanin.dev
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.
anirudh.fi
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 cid "github.com/ipfs/go-cid"
12 cbg "github.com/whyrusleeping/cbor-gen"
13 xerrors "golang.org/x/xerrors"
14)
15
16var _ = xerrors.Errorf
17var _ = cid.Undef
18var _ = math.E
19var _ = sort.Sort
20
21func (t *PublicKey) MarshalCBOR(w io.Writer) error {
22 if t == nil {
23 _, err := w.Write(cbg.CborNull)
24 return err
25 }
26
27 cw := cbg.NewCborWriter(w)
28
29 if _, err := cw.Write([]byte{164}); err != nil {
30 return err
31 }
32
33 // t.Key (string) (string)
34 if len("key") > 1000000 {
35 return xerrors.Errorf("Value in field \"key\" was too long")
36 }
37
38 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
39 return err
40 }
41 if _, err := cw.WriteString(string("key")); err != nil {
42 return err
43 }
44
45 if len(t.Key) > 1000000 {
46 return xerrors.Errorf("Value in field t.Key was too long")
47 }
48
49 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
50 return err
51 }
52 if _, err := cw.WriteString(string(t.Key)); err != nil {
53 return err
54 }
55
56 // t.Name (string) (string)
57 if len("name") > 1000000 {
58 return xerrors.Errorf("Value in field \"name\" was too long")
59 }
60
61 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
62 return err
63 }
64 if _, err := cw.WriteString(string("name")); err != nil {
65 return err
66 }
67
68 if len(t.Name) > 1000000 {
69 return xerrors.Errorf("Value in field t.Name was too long")
70 }
71
72 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
73 return err
74 }
75 if _, err := cw.WriteString(string(t.Name)); err != nil {
76 return err
77 }
78
79 // t.LexiconTypeID (string) (string)
80 if len("$type") > 1000000 {
81 return xerrors.Errorf("Value in field \"$type\" was too long")
82 }
83
84 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
85 return err
86 }
87 if _, err := cw.WriteString(string("$type")); err != nil {
88 return err
89 }
90
91 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil {
92 return err
93 }
94 if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil {
95 return err
96 }
97
98 // t.Created (string) (string)
99 if len("created") > 1000000 {
100 return xerrors.Errorf("Value in field \"created\" was too long")
101 }
102
103 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("created"))); err != nil {
104 return err
105 }
106 if _, err := cw.WriteString(string("created")); err != nil {
107 return err
108 }
109
110 if len(t.Created) > 1000000 {
111 return xerrors.Errorf("Value in field t.Created was too long")
112 }
113
114 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Created))); err != nil {
115 return err
116 }
117 if _, err := cw.WriteString(string(t.Created)); err != nil {
118 return err
119 }
120 return nil
121}
122
123func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) {
124 *t = PublicKey{}
125
126 cr := cbg.NewCborReader(r)
127
128 maj, extra, err := cr.ReadHeader()
129 if err != nil {
130 return err
131 }
132 defer func() {
133 if err == io.EOF {
134 err = io.ErrUnexpectedEOF
135 }
136 }()
137
138 if maj != cbg.MajMap {
139 return fmt.Errorf("cbor input should be of type map")
140 }
141
142 if extra > cbg.MaxLength {
143 return fmt.Errorf("PublicKey: map struct too large (%d)", extra)
144 }
145
146 n := extra
147
148 nameBuf := make([]byte, 7)
149 for i := uint64(0); i < n; i++ {
150 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
151 if err != nil {
152 return err
153 }
154
155 if !ok {
156 // Field doesn't exist on this type, so ignore it
157 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
158 return err
159 }
160 continue
161 }
162
163 switch string(nameBuf[:nameLen]) {
164 // t.Key (string) (string)
165 case "key":
166
167 {
168 sval, err := cbg.ReadStringWithMax(cr, 1000000)
169 if err != nil {
170 return err
171 }
172
173 t.Key = string(sval)
174 }
175 // t.Name (string) (string)
176 case "name":
177
178 {
179 sval, err := cbg.ReadStringWithMax(cr, 1000000)
180 if err != nil {
181 return err
182 }
183
184 t.Name = string(sval)
185 }
186 // t.LexiconTypeID (string) (string)
187 case "$type":
188
189 {
190 sval, err := cbg.ReadStringWithMax(cr, 1000000)
191 if err != nil {
192 return err
193 }
194
195 t.LexiconTypeID = string(sval)
196 }
197 // t.Created (string) (string)
198 case "created":
199
200 {
201 sval, err := cbg.ReadStringWithMax(cr, 1000000)
202 if err != nil {
203 return err
204 }
205
206 t.Created = string(sval)
207 }
208
209 default:
210 // Field doesn't exist on this type, so ignore it
211 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
212 return err
213 }
214 }
215 }
216
217 return nil
218}
219func (t *KnotMember) MarshalCBOR(w io.Writer) error {
220 if t == nil {
221 _, err := w.Write(cbg.CborNull)
222 return err
223 }
224
225 cw := cbg.NewCborWriter(w)
226 fieldCount := 4
227
228 if t.AddedAt == nil {
229 fieldCount--
230 }
231
232 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
233 return err
234 }
235
236 // t.LexiconTypeID (string) (string)
237 if len("$type") > 1000000 {
238 return xerrors.Errorf("Value in field \"$type\" was too long")
239 }
240
241 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
242 return err
243 }
244 if _, err := cw.WriteString(string("$type")); err != nil {
245 return err
246 }
247
248 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot.member"))); err != nil {
249 return err
250 }
251 if _, err := cw.WriteString(string("sh.tangled.knot.member")); err != nil {
252 return err
253 }
254
255 // t.Domain (string) (string)
256 if len("domain") > 1000000 {
257 return xerrors.Errorf("Value in field \"domain\" was too long")
258 }
259
260 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("domain"))); err != nil {
261 return err
262 }
263 if _, err := cw.WriteString(string("domain")); err != nil {
264 return err
265 }
266
267 if len(t.Domain) > 1000000 {
268 return xerrors.Errorf("Value in field t.Domain was too long")
269 }
270
271 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Domain))); err != nil {
272 return err
273 }
274 if _, err := cw.WriteString(string(t.Domain)); err != nil {
275 return err
276 }
277
278 // t.Member (string) (string)
279 if len("member") > 1000000 {
280 return xerrors.Errorf("Value in field \"member\" was too long")
281 }
282
283 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("member"))); err != nil {
284 return err
285 }
286 if _, err := cw.WriteString(string("member")); err != nil {
287 return err
288 }
289
290 if len(t.Member) > 1000000 {
291 return xerrors.Errorf("Value in field t.Member was too long")
292 }
293
294 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Member))); err != nil {
295 return err
296 }
297 if _, err := cw.WriteString(string(t.Member)); err != nil {
298 return err
299 }
300
301 // t.AddedAt (string) (string)
302 if t.AddedAt != nil {
303
304 if len("addedAt") > 1000000 {
305 return xerrors.Errorf("Value in field \"addedAt\" was too long")
306 }
307
308 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("addedAt"))); err != nil {
309 return err
310 }
311 if _, err := cw.WriteString(string("addedAt")); err != nil {
312 return err
313 }
314
315 if t.AddedAt == nil {
316 if _, err := cw.Write(cbg.CborNull); err != nil {
317 return err
318 }
319 } else {
320 if len(*t.AddedAt) > 1000000 {
321 return xerrors.Errorf("Value in field t.AddedAt was too long")
322 }
323
324 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.AddedAt))); err != nil {
325 return err
326 }
327 if _, err := cw.WriteString(string(*t.AddedAt)); err != nil {
328 return err
329 }
330 }
331 }
332 return nil
333}
334
335func (t *KnotMember) UnmarshalCBOR(r io.Reader) (err error) {
336 *t = KnotMember{}
337
338 cr := cbg.NewCborReader(r)
339
340 maj, extra, err := cr.ReadHeader()
341 if err != nil {
342 return err
343 }
344 defer func() {
345 if err == io.EOF {
346 err = io.ErrUnexpectedEOF
347 }
348 }()
349
350 if maj != cbg.MajMap {
351 return fmt.Errorf("cbor input should be of type map")
352 }
353
354 if extra > cbg.MaxLength {
355 return fmt.Errorf("KnotMember: map struct too large (%d)", extra)
356 }
357
358 n := extra
359
360 nameBuf := make([]byte, 7)
361 for i := uint64(0); i < n; i++ {
362 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
363 if err != nil {
364 return err
365 }
366
367 if !ok {
368 // Field doesn't exist on this type, so ignore it
369 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
370 return err
371 }
372 continue
373 }
374
375 switch string(nameBuf[:nameLen]) {
376 // t.LexiconTypeID (string) (string)
377 case "$type":
378
379 {
380 sval, err := cbg.ReadStringWithMax(cr, 1000000)
381 if err != nil {
382 return err
383 }
384
385 t.LexiconTypeID = string(sval)
386 }
387 // t.Domain (string) (string)
388 case "domain":
389
390 {
391 sval, err := cbg.ReadStringWithMax(cr, 1000000)
392 if err != nil {
393 return err
394 }
395
396 t.Domain = string(sval)
397 }
398 // t.Member (string) (string)
399 case "member":
400
401 {
402 sval, err := cbg.ReadStringWithMax(cr, 1000000)
403 if err != nil {
404 return err
405 }
406
407 t.Member = string(sval)
408 }
409 // t.AddedAt (string) (string)
410 case "addedAt":
411
412 {
413 b, err := cr.ReadByte()
414 if err != nil {
415 return err
416 }
417 if b != cbg.CborNull[0] {
418 if err := cr.UnreadByte(); err != nil {
419 return err
420 }
421
422 sval, err := cbg.ReadStringWithMax(cr, 1000000)
423 if err != nil {
424 return err
425 }
426
427 t.AddedAt = (*string)(&sval)
428 }
429 }
430
431 default:
432 // Field doesn't exist on this type, so ignore it
433 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
434 return err
435 }
436 }
437 }
438
439 return nil
440}
441func (t *GraphFollow) MarshalCBOR(w io.Writer) error {
442 if t == nil {
443 _, err := w.Write(cbg.CborNull)
444 return err
445 }
446
447 cw := cbg.NewCborWriter(w)
448
449 if _, err := cw.Write([]byte{163}); err != nil {
450 return err
451 }
452
453 // t.LexiconTypeID (string) (string)
454 if len("$type") > 1000000 {
455 return xerrors.Errorf("Value in field \"$type\" was too long")
456 }
457
458 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
459 return err
460 }
461 if _, err := cw.WriteString(string("$type")); err != nil {
462 return err
463 }
464
465 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.graph.follow"))); err != nil {
466 return err
467 }
468 if _, err := cw.WriteString(string("sh.tangled.graph.follow")); err != nil {
469 return err
470 }
471
472 // t.Subject (string) (string)
473 if len("subject") > 1000000 {
474 return xerrors.Errorf("Value in field \"subject\" was too long")
475 }
476
477 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
478 return err
479 }
480 if _, err := cw.WriteString(string("subject")); err != nil {
481 return err
482 }
483
484 if len(t.Subject) > 1000000 {
485 return xerrors.Errorf("Value in field t.Subject was too long")
486 }
487
488 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
489 return err
490 }
491 if _, err := cw.WriteString(string(t.Subject)); err != nil {
492 return err
493 }
494
495 // t.CreatedAt (string) (string)
496 if len("createdAt") > 1000000 {
497 return xerrors.Errorf("Value in field \"createdAt\" was too long")
498 }
499
500 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
501 return err
502 }
503 if _, err := cw.WriteString(string("createdAt")); err != nil {
504 return err
505 }
506
507 if len(t.CreatedAt) > 1000000 {
508 return xerrors.Errorf("Value in field t.CreatedAt was too long")
509 }
510
511 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
512 return err
513 }
514 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
515 return err
516 }
517 return nil
518}
519
520func (t *GraphFollow) UnmarshalCBOR(r io.Reader) (err error) {
521 *t = GraphFollow{}
522
523 cr := cbg.NewCborReader(r)
524
525 maj, extra, err := cr.ReadHeader()
526 if err != nil {
527 return err
528 }
529 defer func() {
530 if err == io.EOF {
531 err = io.ErrUnexpectedEOF
532 }
533 }()
534
535 if maj != cbg.MajMap {
536 return fmt.Errorf("cbor input should be of type map")
537 }
538
539 if extra > cbg.MaxLength {
540 return fmt.Errorf("GraphFollow: map struct too large (%d)", extra)
541 }
542
543 n := extra
544
545 nameBuf := make([]byte, 9)
546 for i := uint64(0); i < n; i++ {
547 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
548 if err != nil {
549 return err
550 }
551
552 if !ok {
553 // Field doesn't exist on this type, so ignore it
554 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
555 return err
556 }
557 continue
558 }
559
560 switch string(nameBuf[:nameLen]) {
561 // t.LexiconTypeID (string) (string)
562 case "$type":
563
564 {
565 sval, err := cbg.ReadStringWithMax(cr, 1000000)
566 if err != nil {
567 return err
568 }
569
570 t.LexiconTypeID = string(sval)
571 }
572 // t.Subject (string) (string)
573 case "subject":
574
575 {
576 sval, err := cbg.ReadStringWithMax(cr, 1000000)
577 if err != nil {
578 return err
579 }
580
581 t.Subject = string(sval)
582 }
583 // t.CreatedAt (string) (string)
584 case "createdAt":
585
586 {
587 sval, err := cbg.ReadStringWithMax(cr, 1000000)
588 if err != nil {
589 return err
590 }
591
592 t.CreatedAt = string(sval)
593 }
594
595 default:
596 // Field doesn't exist on this type, so ignore it
597 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
598 return err
599 }
600 }
601 }
602
603 return nil
604}
605func (t *Repo) MarshalCBOR(w io.Writer) error {
606 if t == nil {
607 _, err := w.Write(cbg.CborNull)
608 return err
609 }
610
611 cw := cbg.NewCborWriter(w)
612 fieldCount := 5
613
614 if t.AddedAt == nil {
615 fieldCount--
616 }
617
618 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
619 return err
620 }
621
622 // t.Knot (string) (string)
623 if len("knot") > 1000000 {
624 return xerrors.Errorf("Value in field \"knot\" was too long")
625 }
626
627 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
628 return err
629 }
630 if _, err := cw.WriteString(string("knot")); err != nil {
631 return err
632 }
633
634 if len(t.Knot) > 1000000 {
635 return xerrors.Errorf("Value in field t.Knot was too long")
636 }
637
638 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
639 return err
640 }
641 if _, err := cw.WriteString(string(t.Knot)); err != nil {
642 return err
643 }
644
645 // t.Name (string) (string)
646 if len("name") > 1000000 {
647 return xerrors.Errorf("Value in field \"name\" was too long")
648 }
649
650 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
651 return err
652 }
653 if _, err := cw.WriteString(string("name")); err != nil {
654 return err
655 }
656
657 if len(t.Name) > 1000000 {
658 return xerrors.Errorf("Value in field t.Name was too long")
659 }
660
661 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
662 return err
663 }
664 if _, err := cw.WriteString(string(t.Name)); err != nil {
665 return err
666 }
667
668 // t.LexiconTypeID (string) (string)
669 if len("$type") > 1000000 {
670 return xerrors.Errorf("Value in field \"$type\" was too long")
671 }
672
673 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
674 return err
675 }
676 if _, err := cw.WriteString(string("$type")); err != nil {
677 return err
678 }
679
680 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil {
681 return err
682 }
683 if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil {
684 return err
685 }
686
687 // t.Owner (string) (string)
688 if len("owner") > 1000000 {
689 return xerrors.Errorf("Value in field \"owner\" was too long")
690 }
691
692 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
693 return err
694 }
695 if _, err := cw.WriteString(string("owner")); err != nil {
696 return err
697 }
698
699 if len(t.Owner) > 1000000 {
700 return xerrors.Errorf("Value in field t.Owner was too long")
701 }
702
703 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {
704 return err
705 }
706 if _, err := cw.WriteString(string(t.Owner)); err != nil {
707 return err
708 }
709
710 // t.AddedAt (string) (string)
711 if t.AddedAt != nil {
712
713 if len("addedAt") > 1000000 {
714 return xerrors.Errorf("Value in field \"addedAt\" was too long")
715 }
716
717 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("addedAt"))); err != nil {
718 return err
719 }
720 if _, err := cw.WriteString(string("addedAt")); err != nil {
721 return err
722 }
723
724 if t.AddedAt == nil {
725 if _, err := cw.Write(cbg.CborNull); err != nil {
726 return err
727 }
728 } else {
729 if len(*t.AddedAt) > 1000000 {
730 return xerrors.Errorf("Value in field t.AddedAt was too long")
731 }
732
733 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.AddedAt))); err != nil {
734 return err
735 }
736 if _, err := cw.WriteString(string(*t.AddedAt)); err != nil {
737 return err
738 }
739 }
740 }
741 return nil
742}
743
744func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) {
745 *t = Repo{}
746
747 cr := cbg.NewCborReader(r)
748
749 maj, extra, err := cr.ReadHeader()
750 if err != nil {
751 return err
752 }
753 defer func() {
754 if err == io.EOF {
755 err = io.ErrUnexpectedEOF
756 }
757 }()
758
759 if maj != cbg.MajMap {
760 return fmt.Errorf("cbor input should be of type map")
761 }
762
763 if extra > cbg.MaxLength {
764 return fmt.Errorf("Repo: map struct too large (%d)", extra)
765 }
766
767 n := extra
768
769 nameBuf := make([]byte, 7)
770 for i := uint64(0); i < n; i++ {
771 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
772 if err != nil {
773 return err
774 }
775
776 if !ok {
777 // Field doesn't exist on this type, so ignore it
778 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
779 return err
780 }
781 continue
782 }
783
784 switch string(nameBuf[:nameLen]) {
785 // t.Knot (string) (string)
786 case "knot":
787
788 {
789 sval, err := cbg.ReadStringWithMax(cr, 1000000)
790 if err != nil {
791 return err
792 }
793
794 t.Knot = string(sval)
795 }
796 // t.Name (string) (string)
797 case "name":
798
799 {
800 sval, err := cbg.ReadStringWithMax(cr, 1000000)
801 if err != nil {
802 return err
803 }
804
805 t.Name = string(sval)
806 }
807 // t.LexiconTypeID (string) (string)
808 case "$type":
809
810 {
811 sval, err := cbg.ReadStringWithMax(cr, 1000000)
812 if err != nil {
813 return err
814 }
815
816 t.LexiconTypeID = string(sval)
817 }
818 // t.Owner (string) (string)
819 case "owner":
820
821 {
822 sval, err := cbg.ReadStringWithMax(cr, 1000000)
823 if err != nil {
824 return err
825 }
826
827 t.Owner = string(sval)
828 }
829 // t.AddedAt (string) (string)
830 case "addedAt":
831
832 {
833 b, err := cr.ReadByte()
834 if err != nil {
835 return err
836 }
837 if b != cbg.CborNull[0] {
838 if err := cr.UnreadByte(); err != nil {
839 return err
840 }
841
842 sval, err := cbg.ReadStringWithMax(cr, 1000000)
843 if err != nil {
844 return err
845 }
846
847 t.AddedAt = (*string)(&sval)
848 }
849 }
850
851 default:
852 // Field doesn't exist on this type, so ignore it
853 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
854 return err
855 }
856 }
857 }
858
859 return nil
860}
861func (t *RepoIssue) MarshalCBOR(w io.Writer) error {
862 if t == nil {
863 _, err := w.Write(cbg.CborNull)
864 return err
865 }
866
867 cw := cbg.NewCborWriter(w)
868 fieldCount := 7
869
870 if t.Body == nil {
871 fieldCount--
872 }
873
874 if t.CreatedAt == nil {
875 fieldCount--
876 }
877
878 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
879 return err
880 }
881
882 // t.Body (string) (string)
883 if t.Body != nil {
884
885 if len("body") > 1000000 {
886 return xerrors.Errorf("Value in field \"body\" was too long")
887 }
888
889 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
890 return err
891 }
892 if _, err := cw.WriteString(string("body")); err != nil {
893 return err
894 }
895
896 if t.Body == nil {
897 if _, err := cw.Write(cbg.CborNull); err != nil {
898 return err
899 }
900 } else {
901 if len(*t.Body) > 1000000 {
902 return xerrors.Errorf("Value in field t.Body was too long")
903 }
904
905 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
906 return err
907 }
908 if _, err := cw.WriteString(string(*t.Body)); err != nil {
909 return err
910 }
911 }
912 }
913
914 // t.Repo (string) (string)
915 if len("repo") > 1000000 {
916 return xerrors.Errorf("Value in field \"repo\" was too long")
917 }
918
919 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
920 return err
921 }
922 if _, err := cw.WriteString(string("repo")); err != nil {
923 return err
924 }
925
926 if len(t.Repo) > 1000000 {
927 return xerrors.Errorf("Value in field t.Repo was too long")
928 }
929
930 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
931 return err
932 }
933 if _, err := cw.WriteString(string(t.Repo)); err != nil {
934 return err
935 }
936
937 // t.LexiconTypeID (string) (string)
938 if len("$type") > 1000000 {
939 return xerrors.Errorf("Value in field \"$type\" was too long")
940 }
941
942 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
943 return err
944 }
945 if _, err := cw.WriteString(string("$type")); err != nil {
946 return err
947 }
948
949 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil {
950 return err
951 }
952 if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil {
953 return err
954 }
955
956 // t.Owner (string) (string)
957 if len("owner") > 1000000 {
958 return xerrors.Errorf("Value in field \"owner\" was too long")
959 }
960
961 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
962 return err
963 }
964 if _, err := cw.WriteString(string("owner")); err != nil {
965 return err
966 }
967
968 if len(t.Owner) > 1000000 {
969 return xerrors.Errorf("Value in field t.Owner was too long")
970 }
971
972 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {
973 return err
974 }
975 if _, err := cw.WriteString(string(t.Owner)); err != nil {
976 return err
977 }
978
979 // t.Title (string) (string)
980 if len("title") > 1000000 {
981 return xerrors.Errorf("Value in field \"title\" was too long")
982 }
983
984 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
985 return err
986 }
987 if _, err := cw.WriteString(string("title")); err != nil {
988 return err
989 }
990
991 if len(t.Title) > 1000000 {
992 return xerrors.Errorf("Value in field t.Title was too long")
993 }
994
995 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
996 return err
997 }
998 if _, err := cw.WriteString(string(t.Title)); err != nil {
999 return err
1000 }
1001
1002 // t.IssueId (int64) (int64)
1003 if len("issueId") > 1000000 {
1004 return xerrors.Errorf("Value in field \"issueId\" was too long")
1005 }
1006
1007 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issueId"))); err != nil {
1008 return err
1009 }
1010 if _, err := cw.WriteString(string("issueId")); err != nil {
1011 return err
1012 }
1013
1014 if t.IssueId >= 0 {
1015 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.IssueId)); err != nil {
1016 return err
1017 }
1018 } else {
1019 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.IssueId-1)); err != nil {
1020 return err
1021 }
1022 }
1023
1024 // t.CreatedAt (string) (string)
1025 if t.CreatedAt != nil {
1026
1027 if len("createdAt") > 1000000 {
1028 return xerrors.Errorf("Value in field \"createdAt\" was too long")
1029 }
1030
1031 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
1032 return err
1033 }
1034 if _, err := cw.WriteString(string("createdAt")); err != nil {
1035 return err
1036 }
1037
1038 if t.CreatedAt == nil {
1039 if _, err := cw.Write(cbg.CborNull); err != nil {
1040 return err
1041 }
1042 } else {
1043 if len(*t.CreatedAt) > 1000000 {
1044 return xerrors.Errorf("Value in field t.CreatedAt was too long")
1045 }
1046
1047 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.CreatedAt))); err != nil {
1048 return err
1049 }
1050 if _, err := cw.WriteString(string(*t.CreatedAt)); err != nil {
1051 return err
1052 }
1053 }
1054 }
1055 return nil
1056}
1057
1058func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) {
1059 *t = RepoIssue{}
1060
1061 cr := cbg.NewCborReader(r)
1062
1063 maj, extra, err := cr.ReadHeader()
1064 if err != nil {
1065 return err
1066 }
1067 defer func() {
1068 if err == io.EOF {
1069 err = io.ErrUnexpectedEOF
1070 }
1071 }()
1072
1073 if maj != cbg.MajMap {
1074 return fmt.Errorf("cbor input should be of type map")
1075 }
1076
1077 if extra > cbg.MaxLength {
1078 return fmt.Errorf("RepoIssue: map struct too large (%d)", extra)
1079 }
1080
1081 n := extra
1082
1083 nameBuf := make([]byte, 9)
1084 for i := uint64(0); i < n; i++ {
1085 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1086 if err != nil {
1087 return err
1088 }
1089
1090 if !ok {
1091 // Field doesn't exist on this type, so ignore it
1092 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1093 return err
1094 }
1095 continue
1096 }
1097
1098 switch string(nameBuf[:nameLen]) {
1099 // t.Body (string) (string)
1100 case "body":
1101
1102 {
1103 b, err := cr.ReadByte()
1104 if err != nil {
1105 return err
1106 }
1107 if b != cbg.CborNull[0] {
1108 if err := cr.UnreadByte(); err != nil {
1109 return err
1110 }
1111
1112 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1113 if err != nil {
1114 return err
1115 }
1116
1117 t.Body = (*string)(&sval)
1118 }
1119 }
1120 // t.Repo (string) (string)
1121 case "repo":
1122
1123 {
1124 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1125 if err != nil {
1126 return err
1127 }
1128
1129 t.Repo = string(sval)
1130 }
1131 // t.LexiconTypeID (string) (string)
1132 case "$type":
1133
1134 {
1135 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1136 if err != nil {
1137 return err
1138 }
1139
1140 t.LexiconTypeID = string(sval)
1141 }
1142 // t.Owner (string) (string)
1143 case "owner":
1144
1145 {
1146 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1147 if err != nil {
1148 return err
1149 }
1150
1151 t.Owner = string(sval)
1152 }
1153 // t.Title (string) (string)
1154 case "title":
1155
1156 {
1157 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1158 if err != nil {
1159 return err
1160 }
1161
1162 t.Title = string(sval)
1163 }
1164 // t.IssueId (int64) (int64)
1165 case "issueId":
1166 {
1167 maj, extra, err := cr.ReadHeader()
1168 if err != nil {
1169 return err
1170 }
1171 var extraI int64
1172 switch maj {
1173 case cbg.MajUnsignedInt:
1174 extraI = int64(extra)
1175 if extraI < 0 {
1176 return fmt.Errorf("int64 positive overflow")
1177 }
1178 case cbg.MajNegativeInt:
1179 extraI = int64(extra)
1180 if extraI < 0 {
1181 return fmt.Errorf("int64 negative overflow")
1182 }
1183 extraI = -1 - extraI
1184 default:
1185 return fmt.Errorf("wrong type for int64 field: %d", maj)
1186 }
1187
1188 t.IssueId = int64(extraI)
1189 }
1190 // t.CreatedAt (string) (string)
1191 case "createdAt":
1192
1193 {
1194 b, err := cr.ReadByte()
1195 if err != nil {
1196 return err
1197 }
1198 if b != cbg.CborNull[0] {
1199 if err := cr.UnreadByte(); err != nil {
1200 return err
1201 }
1202
1203 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1204 if err != nil {
1205 return err
1206 }
1207
1208 t.CreatedAt = (*string)(&sval)
1209 }
1210 }
1211
1212 default:
1213 // Field doesn't exist on this type, so ignore it
1214 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1215 return err
1216 }
1217 }
1218 }
1219
1220 return nil
1221}
1222func (t *RepoIssueState) MarshalCBOR(w io.Writer) error {
1223 if t == nil {
1224 _, err := w.Write(cbg.CborNull)
1225 return err
1226 }
1227
1228 cw := cbg.NewCborWriter(w)
1229 fieldCount := 3
1230
1231 if t.State == nil {
1232 fieldCount--
1233 }
1234
1235 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1236 return err
1237 }
1238
1239 // t.LexiconTypeID (string) (string)
1240 if len("$type") > 1000000 {
1241 return xerrors.Errorf("Value in field \"$type\" was too long")
1242 }
1243
1244 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
1245 return err
1246 }
1247 if _, err := cw.WriteString(string("$type")); err != nil {
1248 return err
1249 }
1250
1251 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil {
1252 return err
1253 }
1254 if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil {
1255 return err
1256 }
1257
1258 // t.Issue (string) (string)
1259 if len("issue") > 1000000 {
1260 return xerrors.Errorf("Value in field \"issue\" was too long")
1261 }
1262
1263 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
1264 return err
1265 }
1266 if _, err := cw.WriteString(string("issue")); err != nil {
1267 return err
1268 }
1269
1270 if len(t.Issue) > 1000000 {
1271 return xerrors.Errorf("Value in field t.Issue was too long")
1272 }
1273
1274 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
1275 return err
1276 }
1277 if _, err := cw.WriteString(string(t.Issue)); err != nil {
1278 return err
1279 }
1280
1281 // t.State (string) (string)
1282 if t.State != nil {
1283
1284 if len("state") > 1000000 {
1285 return xerrors.Errorf("Value in field \"state\" was too long")
1286 }
1287
1288 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil {
1289 return err
1290 }
1291 if _, err := cw.WriteString(string("state")); err != nil {
1292 return err
1293 }
1294
1295 if t.State == nil {
1296 if _, err := cw.Write(cbg.CborNull); err != nil {
1297 return err
1298 }
1299 } else {
1300 if len(*t.State) > 1000000 {
1301 return xerrors.Errorf("Value in field t.State was too long")
1302 }
1303
1304 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.State))); err != nil {
1305 return err
1306 }
1307 if _, err := cw.WriteString(string(*t.State)); err != nil {
1308 return err
1309 }
1310 }
1311 }
1312 return nil
1313}
1314
1315func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) {
1316 *t = RepoIssueState{}
1317
1318 cr := cbg.NewCborReader(r)
1319
1320 maj, extra, err := cr.ReadHeader()
1321 if err != nil {
1322 return err
1323 }
1324 defer func() {
1325 if err == io.EOF {
1326 err = io.ErrUnexpectedEOF
1327 }
1328 }()
1329
1330 if maj != cbg.MajMap {
1331 return fmt.Errorf("cbor input should be of type map")
1332 }
1333
1334 if extra > cbg.MaxLength {
1335 return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra)
1336 }
1337
1338 n := extra
1339
1340 nameBuf := make([]byte, 5)
1341 for i := uint64(0); i < n; i++ {
1342 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1343 if err != nil {
1344 return err
1345 }
1346
1347 if !ok {
1348 // Field doesn't exist on this type, so ignore it
1349 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1350 return err
1351 }
1352 continue
1353 }
1354
1355 switch string(nameBuf[:nameLen]) {
1356 // t.LexiconTypeID (string) (string)
1357 case "$type":
1358
1359 {
1360 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1361 if err != nil {
1362 return err
1363 }
1364
1365 t.LexiconTypeID = string(sval)
1366 }
1367 // t.Issue (string) (string)
1368 case "issue":
1369
1370 {
1371 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1372 if err != nil {
1373 return err
1374 }
1375
1376 t.Issue = string(sval)
1377 }
1378 // t.State (string) (string)
1379 case "state":
1380
1381 {
1382 b, err := cr.ReadByte()
1383 if err != nil {
1384 return err
1385 }
1386 if b != cbg.CborNull[0] {
1387 if err := cr.UnreadByte(); err != nil {
1388 return err
1389 }
1390
1391 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1392 if err != nil {
1393 return err
1394 }
1395
1396 t.State = (*string)(&sval)
1397 }
1398 }
1399
1400 default:
1401 // Field doesn't exist on this type, so ignore it
1402 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1403 return err
1404 }
1405 }
1406 }
1407
1408 return nil
1409}
1410func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error {
1411 if t == nil {
1412 _, err := w.Write(cbg.CborNull)
1413 return err
1414 }
1415
1416 cw := cbg.NewCborWriter(w)
1417 fieldCount := 7
1418
1419 if t.Body == nil {
1420 fieldCount--
1421 }
1422
1423 if t.CommentId == nil {
1424 fieldCount--
1425 }
1426
1427 if t.CreatedAt == nil {
1428 fieldCount--
1429 }
1430
1431 if t.Owner == nil {
1432 fieldCount--
1433 }
1434
1435 if t.Repo == nil {
1436 fieldCount--
1437 }
1438
1439 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1440 return err
1441 }
1442
1443 // t.Body (string) (string)
1444 if t.Body != nil {
1445
1446 if len("body") > 1000000 {
1447 return xerrors.Errorf("Value in field \"body\" was too long")
1448 }
1449
1450 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
1451 return err
1452 }
1453 if _, err := cw.WriteString(string("body")); err != nil {
1454 return err
1455 }
1456
1457 if t.Body == nil {
1458 if _, err := cw.Write(cbg.CborNull); err != nil {
1459 return err
1460 }
1461 } else {
1462 if len(*t.Body) > 1000000 {
1463 return xerrors.Errorf("Value in field t.Body was too long")
1464 }
1465
1466 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
1467 return err
1468 }
1469 if _, err := cw.WriteString(string(*t.Body)); err != nil {
1470 return err
1471 }
1472 }
1473 }
1474
1475 // t.Repo (string) (string)
1476 if t.Repo != nil {
1477
1478 if len("repo") > 1000000 {
1479 return xerrors.Errorf("Value in field \"repo\" was too long")
1480 }
1481
1482 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
1483 return err
1484 }
1485 if _, err := cw.WriteString(string("repo")); err != nil {
1486 return err
1487 }
1488
1489 if t.Repo == nil {
1490 if _, err := cw.Write(cbg.CborNull); err != nil {
1491 return err
1492 }
1493 } else {
1494 if len(*t.Repo) > 1000000 {
1495 return xerrors.Errorf("Value in field t.Repo was too long")
1496 }
1497
1498 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
1499 return err
1500 }
1501 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
1502 return err
1503 }
1504 }
1505 }
1506
1507 // t.LexiconTypeID (string) (string)
1508 if len("$type") > 1000000 {
1509 return xerrors.Errorf("Value in field \"$type\" was too long")
1510 }
1511
1512 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
1513 return err
1514 }
1515 if _, err := cw.WriteString(string("$type")); err != nil {
1516 return err
1517 }
1518
1519 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil {
1520 return err
1521 }
1522 if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil {
1523 return err
1524 }
1525
1526 // t.Issue (string) (string)
1527 if len("issue") > 1000000 {
1528 return xerrors.Errorf("Value in field \"issue\" was too long")
1529 }
1530
1531 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
1532 return err
1533 }
1534 if _, err := cw.WriteString(string("issue")); err != nil {
1535 return err
1536 }
1537
1538 if len(t.Issue) > 1000000 {
1539 return xerrors.Errorf("Value in field t.Issue was too long")
1540 }
1541
1542 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
1543 return err
1544 }
1545 if _, err := cw.WriteString(string(t.Issue)); err != nil {
1546 return err
1547 }
1548
1549 // t.Owner (string) (string)
1550 if t.Owner != nil {
1551
1552 if len("owner") > 1000000 {
1553 return xerrors.Errorf("Value in field \"owner\" was too long")
1554 }
1555
1556 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
1557 return err
1558 }
1559 if _, err := cw.WriteString(string("owner")); err != nil {
1560 return err
1561 }
1562
1563 if t.Owner == nil {
1564 if _, err := cw.Write(cbg.CborNull); err != nil {
1565 return err
1566 }
1567 } else {
1568 if len(*t.Owner) > 1000000 {
1569 return xerrors.Errorf("Value in field t.Owner was too long")
1570 }
1571
1572 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Owner))); err != nil {
1573 return err
1574 }
1575 if _, err := cw.WriteString(string(*t.Owner)); err != nil {
1576 return err
1577 }
1578 }
1579 }
1580
1581 // t.CommentId (int64) (int64)
1582 if t.CommentId != nil {
1583
1584 if len("commentId") > 1000000 {
1585 return xerrors.Errorf("Value in field \"commentId\" was too long")
1586 }
1587
1588 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commentId"))); err != nil {
1589 return err
1590 }
1591 if _, err := cw.WriteString(string("commentId")); err != nil {
1592 return err
1593 }
1594
1595 if t.CommentId == nil {
1596 if _, err := cw.Write(cbg.CborNull); err != nil {
1597 return err
1598 }
1599 } else {
1600 if *t.CommentId >= 0 {
1601 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.CommentId)); err != nil {
1602 return err
1603 }
1604 } else {
1605 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.CommentId-1)); err != nil {
1606 return err
1607 }
1608 }
1609 }
1610
1611 }
1612
1613 // t.CreatedAt (string) (string)
1614 if t.CreatedAt != nil {
1615
1616 if len("createdAt") > 1000000 {
1617 return xerrors.Errorf("Value in field \"createdAt\" was too long")
1618 }
1619
1620 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
1621 return err
1622 }
1623 if _, err := cw.WriteString(string("createdAt")); err != nil {
1624 return err
1625 }
1626
1627 if t.CreatedAt == nil {
1628 if _, err := cw.Write(cbg.CborNull); err != nil {
1629 return err
1630 }
1631 } else {
1632 if len(*t.CreatedAt) > 1000000 {
1633 return xerrors.Errorf("Value in field t.CreatedAt was too long")
1634 }
1635
1636 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.CreatedAt))); err != nil {
1637 return err
1638 }
1639 if _, err := cw.WriteString(string(*t.CreatedAt)); err != nil {
1640 return err
1641 }
1642 }
1643 }
1644 return nil
1645}
1646
1647func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) {
1648 *t = RepoIssueComment{}
1649
1650 cr := cbg.NewCborReader(r)
1651
1652 maj, extra, err := cr.ReadHeader()
1653 if err != nil {
1654 return err
1655 }
1656 defer func() {
1657 if err == io.EOF {
1658 err = io.ErrUnexpectedEOF
1659 }
1660 }()
1661
1662 if maj != cbg.MajMap {
1663 return fmt.Errorf("cbor input should be of type map")
1664 }
1665
1666 if extra > cbg.MaxLength {
1667 return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra)
1668 }
1669
1670 n := extra
1671
1672 nameBuf := make([]byte, 9)
1673 for i := uint64(0); i < n; i++ {
1674 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1675 if err != nil {
1676 return err
1677 }
1678
1679 if !ok {
1680 // Field doesn't exist on this type, so ignore it
1681 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1682 return err
1683 }
1684 continue
1685 }
1686
1687 switch string(nameBuf[:nameLen]) {
1688 // t.Body (string) (string)
1689 case "body":
1690
1691 {
1692 b, err := cr.ReadByte()
1693 if err != nil {
1694 return err
1695 }
1696 if b != cbg.CborNull[0] {
1697 if err := cr.UnreadByte(); err != nil {
1698 return err
1699 }
1700
1701 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1702 if err != nil {
1703 return err
1704 }
1705
1706 t.Body = (*string)(&sval)
1707 }
1708 }
1709 // t.Repo (string) (string)
1710 case "repo":
1711
1712 {
1713 b, err := cr.ReadByte()
1714 if err != nil {
1715 return err
1716 }
1717 if b != cbg.CborNull[0] {
1718 if err := cr.UnreadByte(); err != nil {
1719 return err
1720 }
1721
1722 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1723 if err != nil {
1724 return err
1725 }
1726
1727 t.Repo = (*string)(&sval)
1728 }
1729 }
1730 // t.LexiconTypeID (string) (string)
1731 case "$type":
1732
1733 {
1734 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1735 if err != nil {
1736 return err
1737 }
1738
1739 t.LexiconTypeID = string(sval)
1740 }
1741 // t.Issue (string) (string)
1742 case "issue":
1743
1744 {
1745 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1746 if err != nil {
1747 return err
1748 }
1749
1750 t.Issue = string(sval)
1751 }
1752 // t.Owner (string) (string)
1753 case "owner":
1754
1755 {
1756 b, err := cr.ReadByte()
1757 if err != nil {
1758 return err
1759 }
1760 if b != cbg.CborNull[0] {
1761 if err := cr.UnreadByte(); err != nil {
1762 return err
1763 }
1764
1765 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1766 if err != nil {
1767 return err
1768 }
1769
1770 t.Owner = (*string)(&sval)
1771 }
1772 }
1773 // t.CommentId (int64) (int64)
1774 case "commentId":
1775 {
1776
1777 b, err := cr.ReadByte()
1778 if err != nil {
1779 return err
1780 }
1781 if b != cbg.CborNull[0] {
1782 if err := cr.UnreadByte(); err != nil {
1783 return err
1784 }
1785 maj, extra, err := cr.ReadHeader()
1786 if err != nil {
1787 return err
1788 }
1789 var extraI int64
1790 switch maj {
1791 case cbg.MajUnsignedInt:
1792 extraI = int64(extra)
1793 if extraI < 0 {
1794 return fmt.Errorf("int64 positive overflow")
1795 }
1796 case cbg.MajNegativeInt:
1797 extraI = int64(extra)
1798 if extraI < 0 {
1799 return fmt.Errorf("int64 negative overflow")
1800 }
1801 extraI = -1 - extraI
1802 default:
1803 return fmt.Errorf("wrong type for int64 field: %d", maj)
1804 }
1805
1806 t.CommentId = (*int64)(&extraI)
1807 }
1808 }
1809 // t.CreatedAt (string) (string)
1810 case "createdAt":
1811
1812 {
1813 b, err := cr.ReadByte()
1814 if err != nil {
1815 return err
1816 }
1817 if b != cbg.CborNull[0] {
1818 if err := cr.UnreadByte(); err != nil {
1819 return err
1820 }
1821
1822 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1823 if err != nil {
1824 return err
1825 }
1826
1827 t.CreatedAt = (*string)(&sval)
1828 }
1829 }
1830
1831 default:
1832 // Field doesn't exist on this type, so ignore it
1833 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1834 return err
1835 }
1836 }
1837 }
1838
1839 return nil
1840}