1840 lines
39 kB
1
// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
2
3
package tangled
4
5
import (
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
16
var _ = xerrors.Errorf
17
var _ = cid.Undef
18
var _ = math.E
19
var _ = sort.Sort
20
21
func (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
123
func (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
}
219
func (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
335
func (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
}
441
func (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
520
func (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
}
605
func (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
744
func (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
}
861
func (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
1058
func (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
}
1222
func (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
1315
func (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
}
1410
func (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
1647
func (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
}
1841