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