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