this repo has no description
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 util "github.com/bluesky-social/indigo/lex/util"
12 cid "github.com/ipfs/go-cid"
13 cbg "github.com/whyrusleeping/cbor-gen"
14 xerrors "golang.org/x/xerrors"
15)
16
17var _ = xerrors.Errorf
18var _ = cid.Undef
19var _ = math.E
20var _ = sort.Sort
21
22func (t *ActorProfile) MarshalCBOR(w io.Writer) error {
23 if t == nil {
24 _, err := w.Write(cbg.CborNull)
25 return err
26 }
27
28 cw := cbg.NewCborWriter(w)
29 fieldCount := 8
30
31 if t.Description == nil {
32 fieldCount--
33 }
34
35 if t.Links == nil {
36 fieldCount--
37 }
38
39 if t.Location == nil {
40 fieldCount--
41 }
42
43 if t.PinnedRepositories == nil {
44 fieldCount--
45 }
46
47 if t.Pronouns == nil {
48 fieldCount--
49 }
50
51 if t.Stats == nil {
52 fieldCount--
53 }
54
55 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
56 return err
57 }
58
59 // t.LexiconTypeID (string) (string)
60 if len("$type") > 1000000 {
61 return xerrors.Errorf("Value in field \"$type\" was too long")
62 }
63
64 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
65 return err
66 }
67 if _, err := cw.WriteString(string("$type")); err != nil {
68 return err
69 }
70
71 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.actor.profile"))); err != nil {
72 return err
73 }
74 if _, err := cw.WriteString(string("sh.tangled.actor.profile")); err != nil {
75 return err
76 }
77
78 // t.Links ([]string) (slice)
79 if t.Links != nil {
80
81 if len("links") > 1000000 {
82 return xerrors.Errorf("Value in field \"links\" was too long")
83 }
84
85 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("links"))); err != nil {
86 return err
87 }
88 if _, err := cw.WriteString(string("links")); err != nil {
89 return err
90 }
91
92 if len(t.Links) > 8192 {
93 return xerrors.Errorf("Slice value in field t.Links was too long")
94 }
95
96 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Links))); err != nil {
97 return err
98 }
99 for _, v := range t.Links {
100 if len(v) > 1000000 {
101 return xerrors.Errorf("Value in field v was too long")
102 }
103
104 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
105 return err
106 }
107 if _, err := cw.WriteString(string(v)); err != nil {
108 return err
109 }
110
111 }
112 }
113
114 // t.Stats ([]string) (slice)
115 if t.Stats != nil {
116
117 if len("stats") > 1000000 {
118 return xerrors.Errorf("Value in field \"stats\" was too long")
119 }
120
121 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("stats"))); err != nil {
122 return err
123 }
124 if _, err := cw.WriteString(string("stats")); err != nil {
125 return err
126 }
127
128 if len(t.Stats) > 8192 {
129 return xerrors.Errorf("Slice value in field t.Stats was too long")
130 }
131
132 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Stats))); err != nil {
133 return err
134 }
135 for _, v := range t.Stats {
136 if len(v) > 1000000 {
137 return xerrors.Errorf("Value in field v was too long")
138 }
139
140 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
141 return err
142 }
143 if _, err := cw.WriteString(string(v)); err != nil {
144 return err
145 }
146
147 }
148 }
149
150 // t.Bluesky (bool) (bool)
151 if len("bluesky") > 1000000 {
152 return xerrors.Errorf("Value in field \"bluesky\" was too long")
153 }
154
155 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("bluesky"))); err != nil {
156 return err
157 }
158 if _, err := cw.WriteString(string("bluesky")); err != nil {
159 return err
160 }
161
162 if err := cbg.WriteBool(w, t.Bluesky); err != nil {
163 return err
164 }
165
166 // t.Location (string) (string)
167 if t.Location != nil {
168
169 if len("location") > 1000000 {
170 return xerrors.Errorf("Value in field \"location\" was too long")
171 }
172
173 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("location"))); err != nil {
174 return err
175 }
176 if _, err := cw.WriteString(string("location")); err != nil {
177 return err
178 }
179
180 if t.Location == nil {
181 if _, err := cw.Write(cbg.CborNull); err != nil {
182 return err
183 }
184 } else {
185 if len(*t.Location) > 1000000 {
186 return xerrors.Errorf("Value in field t.Location was too long")
187 }
188
189 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Location))); err != nil {
190 return err
191 }
192 if _, err := cw.WriteString(string(*t.Location)); err != nil {
193 return err
194 }
195 }
196 }
197
198 // t.Pronouns (string) (string)
199 if t.Pronouns != nil {
200
201 if len("pronouns") > 1000000 {
202 return xerrors.Errorf("Value in field \"pronouns\" was too long")
203 }
204
205 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pronouns"))); err != nil {
206 return err
207 }
208 if _, err := cw.WriteString(string("pronouns")); err != nil {
209 return err
210 }
211
212 if t.Pronouns == nil {
213 if _, err := cw.Write(cbg.CborNull); err != nil {
214 return err
215 }
216 } else {
217 if len(*t.Pronouns) > 1000000 {
218 return xerrors.Errorf("Value in field t.Pronouns was too long")
219 }
220
221 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Pronouns))); err != nil {
222 return err
223 }
224 if _, err := cw.WriteString(string(*t.Pronouns)); err != nil {
225 return err
226 }
227 }
228 }
229
230 // t.Description (string) (string)
231 if t.Description != nil {
232
233 if len("description") > 1000000 {
234 return xerrors.Errorf("Value in field \"description\" was too long")
235 }
236
237 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
238 return err
239 }
240 if _, err := cw.WriteString(string("description")); err != nil {
241 return err
242 }
243
244 if t.Description == nil {
245 if _, err := cw.Write(cbg.CborNull); err != nil {
246 return err
247 }
248 } else {
249 if len(*t.Description) > 1000000 {
250 return xerrors.Errorf("Value in field t.Description was too long")
251 }
252
253 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
254 return err
255 }
256 if _, err := cw.WriteString(string(*t.Description)); err != nil {
257 return err
258 }
259 }
260 }
261
262 // t.PinnedRepositories ([]string) (slice)
263 if t.PinnedRepositories != nil {
264
265 if len("pinnedRepositories") > 1000000 {
266 return xerrors.Errorf("Value in field \"pinnedRepositories\" was too long")
267 }
268
269 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pinnedRepositories"))); err != nil {
270 return err
271 }
272 if _, err := cw.WriteString(string("pinnedRepositories")); err != nil {
273 return err
274 }
275
276 if len(t.PinnedRepositories) > 8192 {
277 return xerrors.Errorf("Slice value in field t.PinnedRepositories was too long")
278 }
279
280 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.PinnedRepositories))); err != nil {
281 return err
282 }
283 for _, v := range t.PinnedRepositories {
284 if len(v) > 1000000 {
285 return xerrors.Errorf("Value in field v was too long")
286 }
287
288 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
289 return err
290 }
291 if _, err := cw.WriteString(string(v)); err != nil {
292 return err
293 }
294
295 }
296 }
297 return nil
298}
299
300func (t *ActorProfile) UnmarshalCBOR(r io.Reader) (err error) {
301 *t = ActorProfile{}
302
303 cr := cbg.NewCborReader(r)
304
305 maj, extra, err := cr.ReadHeader()
306 if err != nil {
307 return err
308 }
309 defer func() {
310 if err == io.EOF {
311 err = io.ErrUnexpectedEOF
312 }
313 }()
314
315 if maj != cbg.MajMap {
316 return fmt.Errorf("cbor input should be of type map")
317 }
318
319 if extra > cbg.MaxLength {
320 return fmt.Errorf("ActorProfile: map struct too large (%d)", extra)
321 }
322
323 n := extra
324
325 nameBuf := make([]byte, 18)
326 for i := uint64(0); i < n; i++ {
327 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
328 if err != nil {
329 return err
330 }
331
332 if !ok {
333 // Field doesn't exist on this type, so ignore it
334 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
335 return err
336 }
337 continue
338 }
339
340 switch string(nameBuf[:nameLen]) {
341 // t.LexiconTypeID (string) (string)
342 case "$type":
343
344 {
345 sval, err := cbg.ReadStringWithMax(cr, 1000000)
346 if err != nil {
347 return err
348 }
349
350 t.LexiconTypeID = string(sval)
351 }
352 // t.Links ([]string) (slice)
353 case "links":
354
355 maj, extra, err = cr.ReadHeader()
356 if err != nil {
357 return err
358 }
359
360 if extra > 8192 {
361 return fmt.Errorf("t.Links: array too large (%d)", extra)
362 }
363
364 if maj != cbg.MajArray {
365 return fmt.Errorf("expected cbor array")
366 }
367
368 if extra > 0 {
369 t.Links = make([]string, extra)
370 }
371
372 for i := 0; i < int(extra); i++ {
373 {
374 var maj byte
375 var extra uint64
376 var err error
377 _ = maj
378 _ = extra
379 _ = err
380
381 {
382 sval, err := cbg.ReadStringWithMax(cr, 1000000)
383 if err != nil {
384 return err
385 }
386
387 t.Links[i] = string(sval)
388 }
389
390 }
391 }
392 // t.Stats ([]string) (slice)
393 case "stats":
394
395 maj, extra, err = cr.ReadHeader()
396 if err != nil {
397 return err
398 }
399
400 if extra > 8192 {
401 return fmt.Errorf("t.Stats: array too large (%d)", extra)
402 }
403
404 if maj != cbg.MajArray {
405 return fmt.Errorf("expected cbor array")
406 }
407
408 if extra > 0 {
409 t.Stats = make([]string, extra)
410 }
411
412 for i := 0; i < int(extra); i++ {
413 {
414 var maj byte
415 var extra uint64
416 var err error
417 _ = maj
418 _ = extra
419 _ = err
420
421 {
422 sval, err := cbg.ReadStringWithMax(cr, 1000000)
423 if err != nil {
424 return err
425 }
426
427 t.Stats[i] = string(sval)
428 }
429
430 }
431 }
432 // t.Bluesky (bool) (bool)
433 case "bluesky":
434
435 maj, extra, err = cr.ReadHeader()
436 if err != nil {
437 return err
438 }
439 if maj != cbg.MajOther {
440 return fmt.Errorf("booleans must be major type 7")
441 }
442 switch extra {
443 case 20:
444 t.Bluesky = false
445 case 21:
446 t.Bluesky = true
447 default:
448 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
449 }
450 // t.Location (string) (string)
451 case "location":
452
453 {
454 b, err := cr.ReadByte()
455 if err != nil {
456 return err
457 }
458 if b != cbg.CborNull[0] {
459 if err := cr.UnreadByte(); err != nil {
460 return err
461 }
462
463 sval, err := cbg.ReadStringWithMax(cr, 1000000)
464 if err != nil {
465 return err
466 }
467
468 t.Location = (*string)(&sval)
469 }
470 }
471 // t.Pronouns (string) (string)
472 case "pronouns":
473
474 {
475 b, err := cr.ReadByte()
476 if err != nil {
477 return err
478 }
479 if b != cbg.CborNull[0] {
480 if err := cr.UnreadByte(); err != nil {
481 return err
482 }
483
484 sval, err := cbg.ReadStringWithMax(cr, 1000000)
485 if err != nil {
486 return err
487 }
488
489 t.Pronouns = (*string)(&sval)
490 }
491 }
492 // t.Description (string) (string)
493 case "description":
494
495 {
496 b, err := cr.ReadByte()
497 if err != nil {
498 return err
499 }
500 if b != cbg.CborNull[0] {
501 if err := cr.UnreadByte(); err != nil {
502 return err
503 }
504
505 sval, err := cbg.ReadStringWithMax(cr, 1000000)
506 if err != nil {
507 return err
508 }
509
510 t.Description = (*string)(&sval)
511 }
512 }
513 // t.PinnedRepositories ([]string) (slice)
514 case "pinnedRepositories":
515
516 maj, extra, err = cr.ReadHeader()
517 if err != nil {
518 return err
519 }
520
521 if extra > 8192 {
522 return fmt.Errorf("t.PinnedRepositories: array too large (%d)", extra)
523 }
524
525 if maj != cbg.MajArray {
526 return fmt.Errorf("expected cbor array")
527 }
528
529 if extra > 0 {
530 t.PinnedRepositories = make([]string, extra)
531 }
532
533 for i := 0; i < int(extra); i++ {
534 {
535 var maj byte
536 var extra uint64
537 var err error
538 _ = maj
539 _ = extra
540 _ = err
541
542 {
543 sval, err := cbg.ReadStringWithMax(cr, 1000000)
544 if err != nil {
545 return err
546 }
547
548 t.PinnedRepositories[i] = string(sval)
549 }
550
551 }
552 }
553
554 default:
555 // Field doesn't exist on this type, so ignore it
556 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
557 return err
558 }
559 }
560 }
561
562 return nil
563}
564func (t *Comment) MarshalCBOR(w io.Writer) error {
565 if t == nil {
566 _, err := w.Write(cbg.CborNull)
567 return err
568 }
569
570 cw := cbg.NewCborWriter(w)
571 fieldCount := 7
572
573 if t.Mentions == nil {
574 fieldCount--
575 }
576
577 if t.References == nil {
578 fieldCount--
579 }
580
581 if t.ReplyTo == nil {
582 fieldCount--
583 }
584
585 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
586 return err
587 }
588
589 // t.Body (string) (string)
590 if len("body") > 1000000 {
591 return xerrors.Errorf("Value in field \"body\" was too long")
592 }
593
594 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
595 return err
596 }
597 if _, err := cw.WriteString(string("body")); err != nil {
598 return err
599 }
600
601 if len(t.Body) > 1000000 {
602 return xerrors.Errorf("Value in field t.Body was too long")
603 }
604
605 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
606 return err
607 }
608 if _, err := cw.WriteString(string(t.Body)); err != nil {
609 return err
610 }
611
612 // t.LexiconTypeID (string) (string)
613 if len("$type") > 1000000 {
614 return xerrors.Errorf("Value in field \"$type\" was too long")
615 }
616
617 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
618 return err
619 }
620 if _, err := cw.WriteString(string("$type")); err != nil {
621 return err
622 }
623
624 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.comment"))); err != nil {
625 return err
626 }
627 if _, err := cw.WriteString(string("sh.tangled.comment")); err != nil {
628 return err
629 }
630
631 // t.ReplyTo (string) (string)
632 if t.ReplyTo != nil {
633
634 if len("replyTo") > 1000000 {
635 return xerrors.Errorf("Value in field \"replyTo\" was too long")
636 }
637
638 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("replyTo"))); err != nil {
639 return err
640 }
641 if _, err := cw.WriteString(string("replyTo")); err != nil {
642 return err
643 }
644
645 if t.ReplyTo == nil {
646 if _, err := cw.Write(cbg.CborNull); err != nil {
647 return err
648 }
649 } else {
650 if len(*t.ReplyTo) > 1000000 {
651 return xerrors.Errorf("Value in field t.ReplyTo was too long")
652 }
653
654 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ReplyTo))); err != nil {
655 return err
656 }
657 if _, err := cw.WriteString(string(*t.ReplyTo)); err != nil {
658 return err
659 }
660 }
661 }
662
663 // t.Subject (string) (string)
664 if len("subject") > 1000000 {
665 return xerrors.Errorf("Value in field \"subject\" was too long")
666 }
667
668 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
669 return err
670 }
671 if _, err := cw.WriteString(string("subject")); err != nil {
672 return err
673 }
674
675 if len(t.Subject) > 1000000 {
676 return xerrors.Errorf("Value in field t.Subject was too long")
677 }
678
679 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
680 return err
681 }
682 if _, err := cw.WriteString(string(t.Subject)); err != nil {
683 return err
684 }
685
686 // t.Mentions ([]string) (slice)
687 if t.Mentions != nil {
688
689 if len("mentions") > 1000000 {
690 return xerrors.Errorf("Value in field \"mentions\" was too long")
691 }
692
693 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
694 return err
695 }
696 if _, err := cw.WriteString(string("mentions")); err != nil {
697 return err
698 }
699
700 if len(t.Mentions) > 8192 {
701 return xerrors.Errorf("Slice value in field t.Mentions was too long")
702 }
703
704 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
705 return err
706 }
707 for _, v := range t.Mentions {
708 if len(v) > 1000000 {
709 return xerrors.Errorf("Value in field v was too long")
710 }
711
712 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
713 return err
714 }
715 if _, err := cw.WriteString(string(v)); err != nil {
716 return err
717 }
718
719 }
720 }
721
722 // t.CreatedAt (string) (string)
723 if len("createdAt") > 1000000 {
724 return xerrors.Errorf("Value in field \"createdAt\" was too long")
725 }
726
727 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
728 return err
729 }
730 if _, err := cw.WriteString(string("createdAt")); err != nil {
731 return err
732 }
733
734 if len(t.CreatedAt) > 1000000 {
735 return xerrors.Errorf("Value in field t.CreatedAt was too long")
736 }
737
738 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
739 return err
740 }
741 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
742 return err
743 }
744
745 // t.References ([]string) (slice)
746 if t.References != nil {
747
748 if len("references") > 1000000 {
749 return xerrors.Errorf("Value in field \"references\" was too long")
750 }
751
752 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
753 return err
754 }
755 if _, err := cw.WriteString(string("references")); err != nil {
756 return err
757 }
758
759 if len(t.References) > 8192 {
760 return xerrors.Errorf("Slice value in field t.References was too long")
761 }
762
763 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
764 return err
765 }
766 for _, v := range t.References {
767 if len(v) > 1000000 {
768 return xerrors.Errorf("Value in field v was too long")
769 }
770
771 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
772 return err
773 }
774 if _, err := cw.WriteString(string(v)); err != nil {
775 return err
776 }
777
778 }
779 }
780 return nil
781}
782
783func (t *Comment) UnmarshalCBOR(r io.Reader) (err error) {
784 *t = Comment{}
785
786 cr := cbg.NewCborReader(r)
787
788 maj, extra, err := cr.ReadHeader()
789 if err != nil {
790 return err
791 }
792 defer func() {
793 if err == io.EOF {
794 err = io.ErrUnexpectedEOF
795 }
796 }()
797
798 if maj != cbg.MajMap {
799 return fmt.Errorf("cbor input should be of type map")
800 }
801
802 if extra > cbg.MaxLength {
803 return fmt.Errorf("Comment: map struct too large (%d)", extra)
804 }
805
806 n := extra
807
808 nameBuf := make([]byte, 10)
809 for i := uint64(0); i < n; i++ {
810 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
811 if err != nil {
812 return err
813 }
814
815 if !ok {
816 // Field doesn't exist on this type, so ignore it
817 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
818 return err
819 }
820 continue
821 }
822
823 switch string(nameBuf[:nameLen]) {
824 // t.Body (string) (string)
825 case "body":
826
827 {
828 sval, err := cbg.ReadStringWithMax(cr, 1000000)
829 if err != nil {
830 return err
831 }
832
833 t.Body = string(sval)
834 }
835 // t.LexiconTypeID (string) (string)
836 case "$type":
837
838 {
839 sval, err := cbg.ReadStringWithMax(cr, 1000000)
840 if err != nil {
841 return err
842 }
843
844 t.LexiconTypeID = string(sval)
845 }
846 // t.ReplyTo (string) (string)
847 case "replyTo":
848
849 {
850 b, err := cr.ReadByte()
851 if err != nil {
852 return err
853 }
854 if b != cbg.CborNull[0] {
855 if err := cr.UnreadByte(); err != nil {
856 return err
857 }
858
859 sval, err := cbg.ReadStringWithMax(cr, 1000000)
860 if err != nil {
861 return err
862 }
863
864 t.ReplyTo = (*string)(&sval)
865 }
866 }
867 // t.Subject (string) (string)
868 case "subject":
869
870 {
871 sval, err := cbg.ReadStringWithMax(cr, 1000000)
872 if err != nil {
873 return err
874 }
875
876 t.Subject = string(sval)
877 }
878 // t.Mentions ([]string) (slice)
879 case "mentions":
880
881 maj, extra, err = cr.ReadHeader()
882 if err != nil {
883 return err
884 }
885
886 if extra > 8192 {
887 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
888 }
889
890 if maj != cbg.MajArray {
891 return fmt.Errorf("expected cbor array")
892 }
893
894 if extra > 0 {
895 t.Mentions = make([]string, extra)
896 }
897
898 for i := 0; i < int(extra); i++ {
899 {
900 var maj byte
901 var extra uint64
902 var err error
903 _ = maj
904 _ = extra
905 _ = err
906
907 {
908 sval, err := cbg.ReadStringWithMax(cr, 1000000)
909 if err != nil {
910 return err
911 }
912
913 t.Mentions[i] = string(sval)
914 }
915
916 }
917 }
918 // t.CreatedAt (string) (string)
919 case "createdAt":
920
921 {
922 sval, err := cbg.ReadStringWithMax(cr, 1000000)
923 if err != nil {
924 return err
925 }
926
927 t.CreatedAt = string(sval)
928 }
929 // t.References ([]string) (slice)
930 case "references":
931
932 maj, extra, err = cr.ReadHeader()
933 if err != nil {
934 return err
935 }
936
937 if extra > 8192 {
938 return fmt.Errorf("t.References: array too large (%d)", extra)
939 }
940
941 if maj != cbg.MajArray {
942 return fmt.Errorf("expected cbor array")
943 }
944
945 if extra > 0 {
946 t.References = make([]string, extra)
947 }
948
949 for i := 0; i < int(extra); i++ {
950 {
951 var maj byte
952 var extra uint64
953 var err error
954 _ = maj
955 _ = extra
956 _ = err
957
958 {
959 sval, err := cbg.ReadStringWithMax(cr, 1000000)
960 if err != nil {
961 return err
962 }
963
964 t.References[i] = string(sval)
965 }
966
967 }
968 }
969
970 default:
971 // Field doesn't exist on this type, so ignore it
972 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
973 return err
974 }
975 }
976 }
977
978 return nil
979}
980func (t *FeedReaction) MarshalCBOR(w io.Writer) error {
981 if t == nil {
982 _, err := w.Write(cbg.CborNull)
983 return err
984 }
985
986 cw := cbg.NewCborWriter(w)
987
988 if _, err := cw.Write([]byte{164}); err != nil {
989 return err
990 }
991
992 // t.LexiconTypeID (string) (string)
993 if len("$type") > 1000000 {
994 return xerrors.Errorf("Value in field \"$type\" was too long")
995 }
996
997 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
998 return err
999 }
1000 if _, err := cw.WriteString(string("$type")); err != nil {
1001 return err
1002 }
1003
1004 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.reaction"))); err != nil {
1005 return err
1006 }
1007 if _, err := cw.WriteString(string("sh.tangled.feed.reaction")); err != nil {
1008 return err
1009 }
1010
1011 // t.Subject (string) (string)
1012 if len("subject") > 1000000 {
1013 return xerrors.Errorf("Value in field \"subject\" was too long")
1014 }
1015
1016 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
1017 return err
1018 }
1019 if _, err := cw.WriteString(string("subject")); err != nil {
1020 return err
1021 }
1022
1023 if len(t.Subject) > 1000000 {
1024 return xerrors.Errorf("Value in field t.Subject was too long")
1025 }
1026
1027 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
1028 return err
1029 }
1030 if _, err := cw.WriteString(string(t.Subject)); err != nil {
1031 return err
1032 }
1033
1034 // t.Reaction (string) (string)
1035 if len("reaction") > 1000000 {
1036 return xerrors.Errorf("Value in field \"reaction\" was too long")
1037 }
1038
1039 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("reaction"))); err != nil {
1040 return err
1041 }
1042 if _, err := cw.WriteString(string("reaction")); err != nil {
1043 return err
1044 }
1045
1046 if len(t.Reaction) > 1000000 {
1047 return xerrors.Errorf("Value in field t.Reaction was too long")
1048 }
1049
1050 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Reaction))); err != nil {
1051 return err
1052 }
1053 if _, err := cw.WriteString(string(t.Reaction)); err != nil {
1054 return err
1055 }
1056
1057 // t.CreatedAt (string) (string)
1058 if len("createdAt") > 1000000 {
1059 return xerrors.Errorf("Value in field \"createdAt\" was too long")
1060 }
1061
1062 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
1063 return err
1064 }
1065 if _, err := cw.WriteString(string("createdAt")); err != nil {
1066 return err
1067 }
1068
1069 if len(t.CreatedAt) > 1000000 {
1070 return xerrors.Errorf("Value in field t.CreatedAt was too long")
1071 }
1072
1073 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
1074 return err
1075 }
1076 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
1077 return err
1078 }
1079 return nil
1080}
1081
1082func (t *FeedReaction) UnmarshalCBOR(r io.Reader) (err error) {
1083 *t = FeedReaction{}
1084
1085 cr := cbg.NewCborReader(r)
1086
1087 maj, extra, err := cr.ReadHeader()
1088 if err != nil {
1089 return err
1090 }
1091 defer func() {
1092 if err == io.EOF {
1093 err = io.ErrUnexpectedEOF
1094 }
1095 }()
1096
1097 if maj != cbg.MajMap {
1098 return fmt.Errorf("cbor input should be of type map")
1099 }
1100
1101 if extra > cbg.MaxLength {
1102 return fmt.Errorf("FeedReaction: map struct too large (%d)", extra)
1103 }
1104
1105 n := extra
1106
1107 nameBuf := make([]byte, 9)
1108 for i := uint64(0); i < n; i++ {
1109 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1110 if err != nil {
1111 return err
1112 }
1113
1114 if !ok {
1115 // Field doesn't exist on this type, so ignore it
1116 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1117 return err
1118 }
1119 continue
1120 }
1121
1122 switch string(nameBuf[:nameLen]) {
1123 // t.LexiconTypeID (string) (string)
1124 case "$type":
1125
1126 {
1127 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1128 if err != nil {
1129 return err
1130 }
1131
1132 t.LexiconTypeID = string(sval)
1133 }
1134 // t.Subject (string) (string)
1135 case "subject":
1136
1137 {
1138 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1139 if err != nil {
1140 return err
1141 }
1142
1143 t.Subject = string(sval)
1144 }
1145 // t.Reaction (string) (string)
1146 case "reaction":
1147
1148 {
1149 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1150 if err != nil {
1151 return err
1152 }
1153
1154 t.Reaction = string(sval)
1155 }
1156 // t.CreatedAt (string) (string)
1157 case "createdAt":
1158
1159 {
1160 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1161 if err != nil {
1162 return err
1163 }
1164
1165 t.CreatedAt = string(sval)
1166 }
1167
1168 default:
1169 // Field doesn't exist on this type, so ignore it
1170 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1171 return err
1172 }
1173 }
1174 }
1175
1176 return nil
1177}
1178func (t *FeedStar) MarshalCBOR(w io.Writer) error {
1179 if t == nil {
1180 _, err := w.Write(cbg.CborNull)
1181 return err
1182 }
1183
1184 cw := cbg.NewCborWriter(w)
1185
1186 if _, err := cw.Write([]byte{163}); err != nil {
1187 return err
1188 }
1189
1190 // t.LexiconTypeID (string) (string)
1191 if len("$type") > 1000000 {
1192 return xerrors.Errorf("Value in field \"$type\" was too long")
1193 }
1194
1195 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
1196 return err
1197 }
1198 if _, err := cw.WriteString(string("$type")); err != nil {
1199 return err
1200 }
1201
1202 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.star"))); err != nil {
1203 return err
1204 }
1205 if _, err := cw.WriteString(string("sh.tangled.feed.star")); err != nil {
1206 return err
1207 }
1208
1209 // t.Subject (string) (string)
1210 if len("subject") > 1000000 {
1211 return xerrors.Errorf("Value in field \"subject\" was too long")
1212 }
1213
1214 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
1215 return err
1216 }
1217 if _, err := cw.WriteString(string("subject")); err != nil {
1218 return err
1219 }
1220
1221 if len(t.Subject) > 1000000 {
1222 return xerrors.Errorf("Value in field t.Subject was too long")
1223 }
1224
1225 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
1226 return err
1227 }
1228 if _, err := cw.WriteString(string(t.Subject)); err != nil {
1229 return err
1230 }
1231
1232 // t.CreatedAt (string) (string)
1233 if len("createdAt") > 1000000 {
1234 return xerrors.Errorf("Value in field \"createdAt\" was too long")
1235 }
1236
1237 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
1238 return err
1239 }
1240 if _, err := cw.WriteString(string("createdAt")); err != nil {
1241 return err
1242 }
1243
1244 if len(t.CreatedAt) > 1000000 {
1245 return xerrors.Errorf("Value in field t.CreatedAt was too long")
1246 }
1247
1248 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
1249 return err
1250 }
1251 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
1252 return err
1253 }
1254 return nil
1255}
1256
1257func (t *FeedStar) UnmarshalCBOR(r io.Reader) (err error) {
1258 *t = FeedStar{}
1259
1260 cr := cbg.NewCborReader(r)
1261
1262 maj, extra, err := cr.ReadHeader()
1263 if err != nil {
1264 return err
1265 }
1266 defer func() {
1267 if err == io.EOF {
1268 err = io.ErrUnexpectedEOF
1269 }
1270 }()
1271
1272 if maj != cbg.MajMap {
1273 return fmt.Errorf("cbor input should be of type map")
1274 }
1275
1276 if extra > cbg.MaxLength {
1277 return fmt.Errorf("FeedStar: map struct too large (%d)", extra)
1278 }
1279
1280 n := extra
1281
1282 nameBuf := make([]byte, 9)
1283 for i := uint64(0); i < n; i++ {
1284 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1285 if err != nil {
1286 return err
1287 }
1288
1289 if !ok {
1290 // Field doesn't exist on this type, so ignore it
1291 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1292 return err
1293 }
1294 continue
1295 }
1296
1297 switch string(nameBuf[:nameLen]) {
1298 // t.LexiconTypeID (string) (string)
1299 case "$type":
1300
1301 {
1302 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1303 if err != nil {
1304 return err
1305 }
1306
1307 t.LexiconTypeID = string(sval)
1308 }
1309 // t.Subject (string) (string)
1310 case "subject":
1311
1312 {
1313 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1314 if err != nil {
1315 return err
1316 }
1317
1318 t.Subject = string(sval)
1319 }
1320 // t.CreatedAt (string) (string)
1321 case "createdAt":
1322
1323 {
1324 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1325 if err != nil {
1326 return err
1327 }
1328
1329 t.CreatedAt = string(sval)
1330 }
1331
1332 default:
1333 // Field doesn't exist on this type, so ignore it
1334 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1335 return err
1336 }
1337 }
1338 }
1339
1340 return nil
1341}
1342func (t *GitRefUpdate) MarshalCBOR(w io.Writer) error {
1343 if t == nil {
1344 _, err := w.Write(cbg.CborNull)
1345 return err
1346 }
1347
1348 cw := cbg.NewCborWriter(w)
1349
1350 if _, err := cw.Write([]byte{168}); err != nil {
1351 return err
1352 }
1353
1354 // t.Ref (string) (string)
1355 if len("ref") > 1000000 {
1356 return xerrors.Errorf("Value in field \"ref\" was too long")
1357 }
1358
1359 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
1360 return err
1361 }
1362 if _, err := cw.WriteString(string("ref")); err != nil {
1363 return err
1364 }
1365
1366 if len(t.Ref) > 1000000 {
1367 return xerrors.Errorf("Value in field t.Ref was too long")
1368 }
1369
1370 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
1371 return err
1372 }
1373 if _, err := cw.WriteString(string(t.Ref)); err != nil {
1374 return err
1375 }
1376
1377 // t.Meta (tangled.GitRefUpdate_Meta) (struct)
1378 if len("meta") > 1000000 {
1379 return xerrors.Errorf("Value in field \"meta\" was too long")
1380 }
1381
1382 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil {
1383 return err
1384 }
1385 if _, err := cw.WriteString(string("meta")); err != nil {
1386 return err
1387 }
1388
1389 if err := t.Meta.MarshalCBOR(cw); err != nil {
1390 return err
1391 }
1392
1393 // t.LexiconTypeID (string) (string)
1394 if len("$type") > 1000000 {
1395 return xerrors.Errorf("Value in field \"$type\" was too long")
1396 }
1397
1398 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
1399 return err
1400 }
1401 if _, err := cw.WriteString(string("$type")); err != nil {
1402 return err
1403 }
1404
1405 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.git.refUpdate"))); err != nil {
1406 return err
1407 }
1408 if _, err := cw.WriteString(string("sh.tangled.git.refUpdate")); err != nil {
1409 return err
1410 }
1411
1412 // t.NewSha (string) (string)
1413 if len("newSha") > 1000000 {
1414 return xerrors.Errorf("Value in field \"newSha\" was too long")
1415 }
1416
1417 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
1418 return err
1419 }
1420 if _, err := cw.WriteString(string("newSha")); err != nil {
1421 return err
1422 }
1423
1424 if len(t.NewSha) > 1000000 {
1425 return xerrors.Errorf("Value in field t.NewSha was too long")
1426 }
1427
1428 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
1429 return err
1430 }
1431 if _, err := cw.WriteString(string(t.NewSha)); err != nil {
1432 return err
1433 }
1434
1435 // t.OldSha (string) (string)
1436 if len("oldSha") > 1000000 {
1437 return xerrors.Errorf("Value in field \"oldSha\" was too long")
1438 }
1439
1440 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
1441 return err
1442 }
1443 if _, err := cw.WriteString(string("oldSha")); err != nil {
1444 return err
1445 }
1446
1447 if len(t.OldSha) > 1000000 {
1448 return xerrors.Errorf("Value in field t.OldSha was too long")
1449 }
1450
1451 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
1452 return err
1453 }
1454 if _, err := cw.WriteString(string(t.OldSha)); err != nil {
1455 return err
1456 }
1457
1458 // t.RepoDid (string) (string)
1459 if len("repoDid") > 1000000 {
1460 return xerrors.Errorf("Value in field \"repoDid\" was too long")
1461 }
1462
1463 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
1464 return err
1465 }
1466 if _, err := cw.WriteString(string("repoDid")); err != nil {
1467 return err
1468 }
1469
1470 if len(t.RepoDid) > 1000000 {
1471 return xerrors.Errorf("Value in field t.RepoDid was too long")
1472 }
1473
1474 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoDid))); err != nil {
1475 return err
1476 }
1477 if _, err := cw.WriteString(string(t.RepoDid)); err != nil {
1478 return err
1479 }
1480
1481 // t.RepoName (string) (string)
1482 if len("repoName") > 1000000 {
1483 return xerrors.Errorf("Value in field \"repoName\" was too long")
1484 }
1485
1486 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoName"))); err != nil {
1487 return err
1488 }
1489 if _, err := cw.WriteString(string("repoName")); err != nil {
1490 return err
1491 }
1492
1493 if len(t.RepoName) > 1000000 {
1494 return xerrors.Errorf("Value in field t.RepoName was too long")
1495 }
1496
1497 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoName))); err != nil {
1498 return err
1499 }
1500 if _, err := cw.WriteString(string(t.RepoName)); err != nil {
1501 return err
1502 }
1503
1504 // t.CommitterDid (string) (string)
1505 if len("committerDid") > 1000000 {
1506 return xerrors.Errorf("Value in field \"committerDid\" was too long")
1507 }
1508
1509 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("committerDid"))); err != nil {
1510 return err
1511 }
1512 if _, err := cw.WriteString(string("committerDid")); err != nil {
1513 return err
1514 }
1515
1516 if len(t.CommitterDid) > 1000000 {
1517 return xerrors.Errorf("Value in field t.CommitterDid was too long")
1518 }
1519
1520 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CommitterDid))); err != nil {
1521 return err
1522 }
1523 if _, err := cw.WriteString(string(t.CommitterDid)); err != nil {
1524 return err
1525 }
1526 return nil
1527}
1528
1529func (t *GitRefUpdate) UnmarshalCBOR(r io.Reader) (err error) {
1530 *t = GitRefUpdate{}
1531
1532 cr := cbg.NewCborReader(r)
1533
1534 maj, extra, err := cr.ReadHeader()
1535 if err != nil {
1536 return err
1537 }
1538 defer func() {
1539 if err == io.EOF {
1540 err = io.ErrUnexpectedEOF
1541 }
1542 }()
1543
1544 if maj != cbg.MajMap {
1545 return fmt.Errorf("cbor input should be of type map")
1546 }
1547
1548 if extra > cbg.MaxLength {
1549 return fmt.Errorf("GitRefUpdate: map struct too large (%d)", extra)
1550 }
1551
1552 n := extra
1553
1554 nameBuf := make([]byte, 12)
1555 for i := uint64(0); i < n; i++ {
1556 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1557 if err != nil {
1558 return err
1559 }
1560
1561 if !ok {
1562 // Field doesn't exist on this type, so ignore it
1563 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1564 return err
1565 }
1566 continue
1567 }
1568
1569 switch string(nameBuf[:nameLen]) {
1570 // t.Ref (string) (string)
1571 case "ref":
1572
1573 {
1574 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1575 if err != nil {
1576 return err
1577 }
1578
1579 t.Ref = string(sval)
1580 }
1581 // t.Meta (tangled.GitRefUpdate_Meta) (struct)
1582 case "meta":
1583
1584 {
1585
1586 b, err := cr.ReadByte()
1587 if err != nil {
1588 return err
1589 }
1590 if b != cbg.CborNull[0] {
1591 if err := cr.UnreadByte(); err != nil {
1592 return err
1593 }
1594 t.Meta = new(GitRefUpdate_Meta)
1595 if err := t.Meta.UnmarshalCBOR(cr); err != nil {
1596 return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err)
1597 }
1598 }
1599
1600 }
1601 // t.LexiconTypeID (string) (string)
1602 case "$type":
1603
1604 {
1605 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1606 if err != nil {
1607 return err
1608 }
1609
1610 t.LexiconTypeID = string(sval)
1611 }
1612 // t.NewSha (string) (string)
1613 case "newSha":
1614
1615 {
1616 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1617 if err != nil {
1618 return err
1619 }
1620
1621 t.NewSha = string(sval)
1622 }
1623 // t.OldSha (string) (string)
1624 case "oldSha":
1625
1626 {
1627 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1628 if err != nil {
1629 return err
1630 }
1631
1632 t.OldSha = string(sval)
1633 }
1634 // t.RepoDid (string) (string)
1635 case "repoDid":
1636
1637 {
1638 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1639 if err != nil {
1640 return err
1641 }
1642
1643 t.RepoDid = string(sval)
1644 }
1645 // t.RepoName (string) (string)
1646 case "repoName":
1647
1648 {
1649 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1650 if err != nil {
1651 return err
1652 }
1653
1654 t.RepoName = string(sval)
1655 }
1656 // t.CommitterDid (string) (string)
1657 case "committerDid":
1658
1659 {
1660 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1661 if err != nil {
1662 return err
1663 }
1664
1665 t.CommitterDid = string(sval)
1666 }
1667
1668 default:
1669 // Field doesn't exist on this type, so ignore it
1670 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1671 return err
1672 }
1673 }
1674 }
1675
1676 return nil
1677}
1678func (t *GitRefUpdate_CommitCountBreakdown) MarshalCBOR(w io.Writer) error {
1679 if t == nil {
1680 _, err := w.Write(cbg.CborNull)
1681 return err
1682 }
1683
1684 cw := cbg.NewCborWriter(w)
1685 fieldCount := 1
1686
1687 if t.ByEmail == nil {
1688 fieldCount--
1689 }
1690
1691 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1692 return err
1693 }
1694
1695 // t.ByEmail ([]*tangled.GitRefUpdate_IndividualEmailCommitCount) (slice)
1696 if t.ByEmail != nil {
1697
1698 if len("byEmail") > 1000000 {
1699 return xerrors.Errorf("Value in field \"byEmail\" was too long")
1700 }
1701
1702 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byEmail"))); err != nil {
1703 return err
1704 }
1705 if _, err := cw.WriteString(string("byEmail")); err != nil {
1706 return err
1707 }
1708
1709 if len(t.ByEmail) > 8192 {
1710 return xerrors.Errorf("Slice value in field t.ByEmail was too long")
1711 }
1712
1713 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ByEmail))); err != nil {
1714 return err
1715 }
1716 for _, v := range t.ByEmail {
1717 if err := v.MarshalCBOR(cw); err != nil {
1718 return err
1719 }
1720
1721 }
1722 }
1723 return nil
1724}
1725
1726func (t *GitRefUpdate_CommitCountBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
1727 *t = GitRefUpdate_CommitCountBreakdown{}
1728
1729 cr := cbg.NewCborReader(r)
1730
1731 maj, extra, err := cr.ReadHeader()
1732 if err != nil {
1733 return err
1734 }
1735 defer func() {
1736 if err == io.EOF {
1737 err = io.ErrUnexpectedEOF
1738 }
1739 }()
1740
1741 if maj != cbg.MajMap {
1742 return fmt.Errorf("cbor input should be of type map")
1743 }
1744
1745 if extra > cbg.MaxLength {
1746 return fmt.Errorf("GitRefUpdate_CommitCountBreakdown: map struct too large (%d)", extra)
1747 }
1748
1749 n := extra
1750
1751 nameBuf := make([]byte, 7)
1752 for i := uint64(0); i < n; i++ {
1753 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1754 if err != nil {
1755 return err
1756 }
1757
1758 if !ok {
1759 // Field doesn't exist on this type, so ignore it
1760 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1761 return err
1762 }
1763 continue
1764 }
1765
1766 switch string(nameBuf[:nameLen]) {
1767 // t.ByEmail ([]*tangled.GitRefUpdate_IndividualEmailCommitCount) (slice)
1768 case "byEmail":
1769
1770 maj, extra, err = cr.ReadHeader()
1771 if err != nil {
1772 return err
1773 }
1774
1775 if extra > 8192 {
1776 return fmt.Errorf("t.ByEmail: array too large (%d)", extra)
1777 }
1778
1779 if maj != cbg.MajArray {
1780 return fmt.Errorf("expected cbor array")
1781 }
1782
1783 if extra > 0 {
1784 t.ByEmail = make([]*GitRefUpdate_IndividualEmailCommitCount, extra)
1785 }
1786
1787 for i := 0; i < int(extra); i++ {
1788 {
1789 var maj byte
1790 var extra uint64
1791 var err error
1792 _ = maj
1793 _ = extra
1794 _ = err
1795
1796 {
1797
1798 b, err := cr.ReadByte()
1799 if err != nil {
1800 return err
1801 }
1802 if b != cbg.CborNull[0] {
1803 if err := cr.UnreadByte(); err != nil {
1804 return err
1805 }
1806 t.ByEmail[i] = new(GitRefUpdate_IndividualEmailCommitCount)
1807 if err := t.ByEmail[i].UnmarshalCBOR(cr); err != nil {
1808 return xerrors.Errorf("unmarshaling t.ByEmail[i] pointer: %w", err)
1809 }
1810 }
1811
1812 }
1813
1814 }
1815 }
1816
1817 default:
1818 // Field doesn't exist on this type, so ignore it
1819 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1820 return err
1821 }
1822 }
1823 }
1824
1825 return nil
1826}
1827func (t *GitRefUpdate_IndividualEmailCommitCount) MarshalCBOR(w io.Writer) error {
1828 if t == nil {
1829 _, err := w.Write(cbg.CborNull)
1830 return err
1831 }
1832
1833 cw := cbg.NewCborWriter(w)
1834
1835 if _, err := cw.Write([]byte{162}); err != nil {
1836 return err
1837 }
1838
1839 // t.Count (int64) (int64)
1840 if len("count") > 1000000 {
1841 return xerrors.Errorf("Value in field \"count\" was too long")
1842 }
1843
1844 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("count"))); err != nil {
1845 return err
1846 }
1847 if _, err := cw.WriteString(string("count")); err != nil {
1848 return err
1849 }
1850
1851 if t.Count >= 0 {
1852 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Count)); err != nil {
1853 return err
1854 }
1855 } else {
1856 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Count-1)); err != nil {
1857 return err
1858 }
1859 }
1860
1861 // t.Email (string) (string)
1862 if len("email") > 1000000 {
1863 return xerrors.Errorf("Value in field \"email\" was too long")
1864 }
1865
1866 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("email"))); err != nil {
1867 return err
1868 }
1869 if _, err := cw.WriteString(string("email")); err != nil {
1870 return err
1871 }
1872
1873 if len(t.Email) > 1000000 {
1874 return xerrors.Errorf("Value in field t.Email was too long")
1875 }
1876
1877 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Email))); err != nil {
1878 return err
1879 }
1880 if _, err := cw.WriteString(string(t.Email)); err != nil {
1881 return err
1882 }
1883 return nil
1884}
1885
1886func (t *GitRefUpdate_IndividualEmailCommitCount) UnmarshalCBOR(r io.Reader) (err error) {
1887 *t = GitRefUpdate_IndividualEmailCommitCount{}
1888
1889 cr := cbg.NewCborReader(r)
1890
1891 maj, extra, err := cr.ReadHeader()
1892 if err != nil {
1893 return err
1894 }
1895 defer func() {
1896 if err == io.EOF {
1897 err = io.ErrUnexpectedEOF
1898 }
1899 }()
1900
1901 if maj != cbg.MajMap {
1902 return fmt.Errorf("cbor input should be of type map")
1903 }
1904
1905 if extra > cbg.MaxLength {
1906 return fmt.Errorf("GitRefUpdate_IndividualEmailCommitCount: map struct too large (%d)", extra)
1907 }
1908
1909 n := extra
1910
1911 nameBuf := make([]byte, 5)
1912 for i := uint64(0); i < n; i++ {
1913 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1914 if err != nil {
1915 return err
1916 }
1917
1918 if !ok {
1919 // Field doesn't exist on this type, so ignore it
1920 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1921 return err
1922 }
1923 continue
1924 }
1925
1926 switch string(nameBuf[:nameLen]) {
1927 // t.Count (int64) (int64)
1928 case "count":
1929 {
1930 maj, extra, err := cr.ReadHeader()
1931 if err != nil {
1932 return err
1933 }
1934 var extraI int64
1935 switch maj {
1936 case cbg.MajUnsignedInt:
1937 extraI = int64(extra)
1938 if extraI < 0 {
1939 return fmt.Errorf("int64 positive overflow")
1940 }
1941 case cbg.MajNegativeInt:
1942 extraI = int64(extra)
1943 if extraI < 0 {
1944 return fmt.Errorf("int64 negative overflow")
1945 }
1946 extraI = -1 - extraI
1947 default:
1948 return fmt.Errorf("wrong type for int64 field: %d", maj)
1949 }
1950
1951 t.Count = int64(extraI)
1952 }
1953 // t.Email (string) (string)
1954 case "email":
1955
1956 {
1957 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1958 if err != nil {
1959 return err
1960 }
1961
1962 t.Email = string(sval)
1963 }
1964
1965 default:
1966 // Field doesn't exist on this type, so ignore it
1967 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1968 return err
1969 }
1970 }
1971 }
1972
1973 return nil
1974}
1975func (t *GitRefUpdate_IndividualLanguageSize) MarshalCBOR(w io.Writer) error {
1976 if t == nil {
1977 _, err := w.Write(cbg.CborNull)
1978 return err
1979 }
1980
1981 cw := cbg.NewCborWriter(w)
1982
1983 if _, err := cw.Write([]byte{162}); err != nil {
1984 return err
1985 }
1986
1987 // t.Lang (string) (string)
1988 if len("lang") > 1000000 {
1989 return xerrors.Errorf("Value in field \"lang\" was too long")
1990 }
1991
1992 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil {
1993 return err
1994 }
1995 if _, err := cw.WriteString(string("lang")); err != nil {
1996 return err
1997 }
1998
1999 if len(t.Lang) > 1000000 {
2000 return xerrors.Errorf("Value in field t.Lang was too long")
2001 }
2002
2003 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil {
2004 return err
2005 }
2006 if _, err := cw.WriteString(string(t.Lang)); err != nil {
2007 return err
2008 }
2009
2010 // t.Size (int64) (int64)
2011 if len("size") > 1000000 {
2012 return xerrors.Errorf("Value in field \"size\" was too long")
2013 }
2014
2015 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil {
2016 return err
2017 }
2018 if _, err := cw.WriteString(string("size")); err != nil {
2019 return err
2020 }
2021
2022 if t.Size >= 0 {
2023 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil {
2024 return err
2025 }
2026 } else {
2027 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); err != nil {
2028 return err
2029 }
2030 }
2031
2032 return nil
2033}
2034
2035func (t *GitRefUpdate_IndividualLanguageSize) UnmarshalCBOR(r io.Reader) (err error) {
2036 *t = GitRefUpdate_IndividualLanguageSize{}
2037
2038 cr := cbg.NewCborReader(r)
2039
2040 maj, extra, err := cr.ReadHeader()
2041 if err != nil {
2042 return err
2043 }
2044 defer func() {
2045 if err == io.EOF {
2046 err = io.ErrUnexpectedEOF
2047 }
2048 }()
2049
2050 if maj != cbg.MajMap {
2051 return fmt.Errorf("cbor input should be of type map")
2052 }
2053
2054 if extra > cbg.MaxLength {
2055 return fmt.Errorf("GitRefUpdate_IndividualLanguageSize: map struct too large (%d)", extra)
2056 }
2057
2058 n := extra
2059
2060 nameBuf := make([]byte, 4)
2061 for i := uint64(0); i < n; i++ {
2062 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2063 if err != nil {
2064 return err
2065 }
2066
2067 if !ok {
2068 // Field doesn't exist on this type, so ignore it
2069 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2070 return err
2071 }
2072 continue
2073 }
2074
2075 switch string(nameBuf[:nameLen]) {
2076 // t.Lang (string) (string)
2077 case "lang":
2078
2079 {
2080 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2081 if err != nil {
2082 return err
2083 }
2084
2085 t.Lang = string(sval)
2086 }
2087 // t.Size (int64) (int64)
2088 case "size":
2089 {
2090 maj, extra, err := cr.ReadHeader()
2091 if err != nil {
2092 return err
2093 }
2094 var extraI int64
2095 switch maj {
2096 case cbg.MajUnsignedInt:
2097 extraI = int64(extra)
2098 if extraI < 0 {
2099 return fmt.Errorf("int64 positive overflow")
2100 }
2101 case cbg.MajNegativeInt:
2102 extraI = int64(extra)
2103 if extraI < 0 {
2104 return fmt.Errorf("int64 negative overflow")
2105 }
2106 extraI = -1 - extraI
2107 default:
2108 return fmt.Errorf("wrong type for int64 field: %d", maj)
2109 }
2110
2111 t.Size = int64(extraI)
2112 }
2113
2114 default:
2115 // Field doesn't exist on this type, so ignore it
2116 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2117 return err
2118 }
2119 }
2120 }
2121
2122 return nil
2123}
2124func (t *GitRefUpdate_LangBreakdown) MarshalCBOR(w io.Writer) error {
2125 if t == nil {
2126 _, err := w.Write(cbg.CborNull)
2127 return err
2128 }
2129
2130 cw := cbg.NewCborWriter(w)
2131 fieldCount := 1
2132
2133 if t.Inputs == nil {
2134 fieldCount--
2135 }
2136
2137 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2138 return err
2139 }
2140
2141 // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice)
2142 if t.Inputs != nil {
2143
2144 if len("inputs") > 1000000 {
2145 return xerrors.Errorf("Value in field \"inputs\" was too long")
2146 }
2147
2148 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
2149 return err
2150 }
2151 if _, err := cw.WriteString(string("inputs")); err != nil {
2152 return err
2153 }
2154
2155 if len(t.Inputs) > 8192 {
2156 return xerrors.Errorf("Slice value in field t.Inputs was too long")
2157 }
2158
2159 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
2160 return err
2161 }
2162 for _, v := range t.Inputs {
2163 if err := v.MarshalCBOR(cw); err != nil {
2164 return err
2165 }
2166
2167 }
2168 }
2169 return nil
2170}
2171
2172func (t *GitRefUpdate_LangBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
2173 *t = GitRefUpdate_LangBreakdown{}
2174
2175 cr := cbg.NewCborReader(r)
2176
2177 maj, extra, err := cr.ReadHeader()
2178 if err != nil {
2179 return err
2180 }
2181 defer func() {
2182 if err == io.EOF {
2183 err = io.ErrUnexpectedEOF
2184 }
2185 }()
2186
2187 if maj != cbg.MajMap {
2188 return fmt.Errorf("cbor input should be of type map")
2189 }
2190
2191 if extra > cbg.MaxLength {
2192 return fmt.Errorf("GitRefUpdate_LangBreakdown: map struct too large (%d)", extra)
2193 }
2194
2195 n := extra
2196
2197 nameBuf := make([]byte, 6)
2198 for i := uint64(0); i < n; i++ {
2199 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2200 if err != nil {
2201 return err
2202 }
2203
2204 if !ok {
2205 // Field doesn't exist on this type, so ignore it
2206 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2207 return err
2208 }
2209 continue
2210 }
2211
2212 switch string(nameBuf[:nameLen]) {
2213 // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice)
2214 case "inputs":
2215
2216 maj, extra, err = cr.ReadHeader()
2217 if err != nil {
2218 return err
2219 }
2220
2221 if extra > 8192 {
2222 return fmt.Errorf("t.Inputs: array too large (%d)", extra)
2223 }
2224
2225 if maj != cbg.MajArray {
2226 return fmt.Errorf("expected cbor array")
2227 }
2228
2229 if extra > 0 {
2230 t.Inputs = make([]*GitRefUpdate_IndividualLanguageSize, extra)
2231 }
2232
2233 for i := 0; i < int(extra); i++ {
2234 {
2235 var maj byte
2236 var extra uint64
2237 var err error
2238 _ = maj
2239 _ = extra
2240 _ = err
2241
2242 {
2243
2244 b, err := cr.ReadByte()
2245 if err != nil {
2246 return err
2247 }
2248 if b != cbg.CborNull[0] {
2249 if err := cr.UnreadByte(); err != nil {
2250 return err
2251 }
2252 t.Inputs[i] = new(GitRefUpdate_IndividualLanguageSize)
2253 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
2254 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
2255 }
2256 }
2257
2258 }
2259
2260 }
2261 }
2262
2263 default:
2264 // Field doesn't exist on this type, so ignore it
2265 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2266 return err
2267 }
2268 }
2269 }
2270
2271 return nil
2272}
2273func (t *GitRefUpdate_Meta) MarshalCBOR(w io.Writer) error {
2274 if t == nil {
2275 _, err := w.Write(cbg.CborNull)
2276 return err
2277 }
2278
2279 cw := cbg.NewCborWriter(w)
2280 fieldCount := 3
2281
2282 if t.LangBreakdown == nil {
2283 fieldCount--
2284 }
2285
2286 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2287 return err
2288 }
2289
2290 // t.CommitCount (tangled.GitRefUpdate_CommitCountBreakdown) (struct)
2291 if len("commitCount") > 1000000 {
2292 return xerrors.Errorf("Value in field \"commitCount\" was too long")
2293 }
2294
2295 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commitCount"))); err != nil {
2296 return err
2297 }
2298 if _, err := cw.WriteString(string("commitCount")); err != nil {
2299 return err
2300 }
2301
2302 if err := t.CommitCount.MarshalCBOR(cw); err != nil {
2303 return err
2304 }
2305
2306 // t.IsDefaultRef (bool) (bool)
2307 if len("isDefaultRef") > 1000000 {
2308 return xerrors.Errorf("Value in field \"isDefaultRef\" was too long")
2309 }
2310
2311 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("isDefaultRef"))); err != nil {
2312 return err
2313 }
2314 if _, err := cw.WriteString(string("isDefaultRef")); err != nil {
2315 return err
2316 }
2317
2318 if err := cbg.WriteBool(w, t.IsDefaultRef); err != nil {
2319 return err
2320 }
2321
2322 // t.LangBreakdown (tangled.GitRefUpdate_LangBreakdown) (struct)
2323 if t.LangBreakdown != nil {
2324
2325 if len("langBreakdown") > 1000000 {
2326 return xerrors.Errorf("Value in field \"langBreakdown\" was too long")
2327 }
2328
2329 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("langBreakdown"))); err != nil {
2330 return err
2331 }
2332 if _, err := cw.WriteString(string("langBreakdown")); err != nil {
2333 return err
2334 }
2335
2336 if err := t.LangBreakdown.MarshalCBOR(cw); err != nil {
2337 return err
2338 }
2339 }
2340 return nil
2341}
2342
2343func (t *GitRefUpdate_Meta) UnmarshalCBOR(r io.Reader) (err error) {
2344 *t = GitRefUpdate_Meta{}
2345
2346 cr := cbg.NewCborReader(r)
2347
2348 maj, extra, err := cr.ReadHeader()
2349 if err != nil {
2350 return err
2351 }
2352 defer func() {
2353 if err == io.EOF {
2354 err = io.ErrUnexpectedEOF
2355 }
2356 }()
2357
2358 if maj != cbg.MajMap {
2359 return fmt.Errorf("cbor input should be of type map")
2360 }
2361
2362 if extra > cbg.MaxLength {
2363 return fmt.Errorf("GitRefUpdate_Meta: map struct too large (%d)", extra)
2364 }
2365
2366 n := extra
2367
2368 nameBuf := make([]byte, 13)
2369 for i := uint64(0); i < n; i++ {
2370 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2371 if err != nil {
2372 return err
2373 }
2374
2375 if !ok {
2376 // Field doesn't exist on this type, so ignore it
2377 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2378 return err
2379 }
2380 continue
2381 }
2382
2383 switch string(nameBuf[:nameLen]) {
2384 // t.CommitCount (tangled.GitRefUpdate_CommitCountBreakdown) (struct)
2385 case "commitCount":
2386
2387 {
2388
2389 b, err := cr.ReadByte()
2390 if err != nil {
2391 return err
2392 }
2393 if b != cbg.CborNull[0] {
2394 if err := cr.UnreadByte(); err != nil {
2395 return err
2396 }
2397 t.CommitCount = new(GitRefUpdate_CommitCountBreakdown)
2398 if err := t.CommitCount.UnmarshalCBOR(cr); err != nil {
2399 return xerrors.Errorf("unmarshaling t.CommitCount pointer: %w", err)
2400 }
2401 }
2402
2403 }
2404 // t.IsDefaultRef (bool) (bool)
2405 case "isDefaultRef":
2406
2407 maj, extra, err = cr.ReadHeader()
2408 if err != nil {
2409 return err
2410 }
2411 if maj != cbg.MajOther {
2412 return fmt.Errorf("booleans must be major type 7")
2413 }
2414 switch extra {
2415 case 20:
2416 t.IsDefaultRef = false
2417 case 21:
2418 t.IsDefaultRef = true
2419 default:
2420 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
2421 }
2422 // t.LangBreakdown (tangled.GitRefUpdate_LangBreakdown) (struct)
2423 case "langBreakdown":
2424
2425 {
2426
2427 b, err := cr.ReadByte()
2428 if err != nil {
2429 return err
2430 }
2431 if b != cbg.CborNull[0] {
2432 if err := cr.UnreadByte(); err != nil {
2433 return err
2434 }
2435 t.LangBreakdown = new(GitRefUpdate_LangBreakdown)
2436 if err := t.LangBreakdown.UnmarshalCBOR(cr); err != nil {
2437 return xerrors.Errorf("unmarshaling t.LangBreakdown pointer: %w", err)
2438 }
2439 }
2440
2441 }
2442
2443 default:
2444 // Field doesn't exist on this type, so ignore it
2445 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2446 return err
2447 }
2448 }
2449 }
2450
2451 return nil
2452}
2453func (t *GraphFollow) MarshalCBOR(w io.Writer) error {
2454 if t == nil {
2455 _, err := w.Write(cbg.CborNull)
2456 return err
2457 }
2458
2459 cw := cbg.NewCborWriter(w)
2460
2461 if _, err := cw.Write([]byte{163}); err != nil {
2462 return err
2463 }
2464
2465 // t.LexiconTypeID (string) (string)
2466 if len("$type") > 1000000 {
2467 return xerrors.Errorf("Value in field \"$type\" was too long")
2468 }
2469
2470 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2471 return err
2472 }
2473 if _, err := cw.WriteString(string("$type")); err != nil {
2474 return err
2475 }
2476
2477 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.graph.follow"))); err != nil {
2478 return err
2479 }
2480 if _, err := cw.WriteString(string("sh.tangled.graph.follow")); err != nil {
2481 return err
2482 }
2483
2484 // t.Subject (string) (string)
2485 if len("subject") > 1000000 {
2486 return xerrors.Errorf("Value in field \"subject\" was too long")
2487 }
2488
2489 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
2490 return err
2491 }
2492 if _, err := cw.WriteString(string("subject")); err != nil {
2493 return err
2494 }
2495
2496 if len(t.Subject) > 1000000 {
2497 return xerrors.Errorf("Value in field t.Subject was too long")
2498 }
2499
2500 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
2501 return err
2502 }
2503 if _, err := cw.WriteString(string(t.Subject)); err != nil {
2504 return err
2505 }
2506
2507 // t.CreatedAt (string) (string)
2508 if len("createdAt") > 1000000 {
2509 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2510 }
2511
2512 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2513 return err
2514 }
2515 if _, err := cw.WriteString(string("createdAt")); err != nil {
2516 return err
2517 }
2518
2519 if len(t.CreatedAt) > 1000000 {
2520 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2521 }
2522
2523 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2524 return err
2525 }
2526 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2527 return err
2528 }
2529 return nil
2530}
2531
2532func (t *GraphFollow) UnmarshalCBOR(r io.Reader) (err error) {
2533 *t = GraphFollow{}
2534
2535 cr := cbg.NewCborReader(r)
2536
2537 maj, extra, err := cr.ReadHeader()
2538 if err != nil {
2539 return err
2540 }
2541 defer func() {
2542 if err == io.EOF {
2543 err = io.ErrUnexpectedEOF
2544 }
2545 }()
2546
2547 if maj != cbg.MajMap {
2548 return fmt.Errorf("cbor input should be of type map")
2549 }
2550
2551 if extra > cbg.MaxLength {
2552 return fmt.Errorf("GraphFollow: map struct too large (%d)", extra)
2553 }
2554
2555 n := extra
2556
2557 nameBuf := make([]byte, 9)
2558 for i := uint64(0); i < n; i++ {
2559 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2560 if err != nil {
2561 return err
2562 }
2563
2564 if !ok {
2565 // Field doesn't exist on this type, so ignore it
2566 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2567 return err
2568 }
2569 continue
2570 }
2571
2572 switch string(nameBuf[:nameLen]) {
2573 // t.LexiconTypeID (string) (string)
2574 case "$type":
2575
2576 {
2577 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2578 if err != nil {
2579 return err
2580 }
2581
2582 t.LexiconTypeID = string(sval)
2583 }
2584 // t.Subject (string) (string)
2585 case "subject":
2586
2587 {
2588 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2589 if err != nil {
2590 return err
2591 }
2592
2593 t.Subject = string(sval)
2594 }
2595 // t.CreatedAt (string) (string)
2596 case "createdAt":
2597
2598 {
2599 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2600 if err != nil {
2601 return err
2602 }
2603
2604 t.CreatedAt = string(sval)
2605 }
2606
2607 default:
2608 // Field doesn't exist on this type, so ignore it
2609 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2610 return err
2611 }
2612 }
2613 }
2614
2615 return nil
2616}
2617func (t *Knot) MarshalCBOR(w io.Writer) error {
2618 if t == nil {
2619 _, err := w.Write(cbg.CborNull)
2620 return err
2621 }
2622
2623 cw := cbg.NewCborWriter(w)
2624
2625 if _, err := cw.Write([]byte{162}); err != nil {
2626 return err
2627 }
2628
2629 // t.LexiconTypeID (string) (string)
2630 if len("$type") > 1000000 {
2631 return xerrors.Errorf("Value in field \"$type\" was too long")
2632 }
2633
2634 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2635 return err
2636 }
2637 if _, err := cw.WriteString(string("$type")); err != nil {
2638 return err
2639 }
2640
2641 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot"))); err != nil {
2642 return err
2643 }
2644 if _, err := cw.WriteString(string("sh.tangled.knot")); err != nil {
2645 return err
2646 }
2647
2648 // t.CreatedAt (string) (string)
2649 if len("createdAt") > 1000000 {
2650 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2651 }
2652
2653 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2654 return err
2655 }
2656 if _, err := cw.WriteString(string("createdAt")); err != nil {
2657 return err
2658 }
2659
2660 if len(t.CreatedAt) > 1000000 {
2661 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2662 }
2663
2664 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2665 return err
2666 }
2667 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2668 return err
2669 }
2670 return nil
2671}
2672
2673func (t *Knot) UnmarshalCBOR(r io.Reader) (err error) {
2674 *t = Knot{}
2675
2676 cr := cbg.NewCborReader(r)
2677
2678 maj, extra, err := cr.ReadHeader()
2679 if err != nil {
2680 return err
2681 }
2682 defer func() {
2683 if err == io.EOF {
2684 err = io.ErrUnexpectedEOF
2685 }
2686 }()
2687
2688 if maj != cbg.MajMap {
2689 return fmt.Errorf("cbor input should be of type map")
2690 }
2691
2692 if extra > cbg.MaxLength {
2693 return fmt.Errorf("Knot: map struct too large (%d)", extra)
2694 }
2695
2696 n := extra
2697
2698 nameBuf := make([]byte, 9)
2699 for i := uint64(0); i < n; i++ {
2700 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2701 if err != nil {
2702 return err
2703 }
2704
2705 if !ok {
2706 // Field doesn't exist on this type, so ignore it
2707 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2708 return err
2709 }
2710 continue
2711 }
2712
2713 switch string(nameBuf[:nameLen]) {
2714 // t.LexiconTypeID (string) (string)
2715 case "$type":
2716
2717 {
2718 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2719 if err != nil {
2720 return err
2721 }
2722
2723 t.LexiconTypeID = string(sval)
2724 }
2725 // t.CreatedAt (string) (string)
2726 case "createdAt":
2727
2728 {
2729 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2730 if err != nil {
2731 return err
2732 }
2733
2734 t.CreatedAt = string(sval)
2735 }
2736
2737 default:
2738 // Field doesn't exist on this type, so ignore it
2739 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2740 return err
2741 }
2742 }
2743 }
2744
2745 return nil
2746}
2747func (t *KnotMember) MarshalCBOR(w io.Writer) error {
2748 if t == nil {
2749 _, err := w.Write(cbg.CborNull)
2750 return err
2751 }
2752
2753 cw := cbg.NewCborWriter(w)
2754
2755 if _, err := cw.Write([]byte{164}); err != nil {
2756 return err
2757 }
2758
2759 // t.LexiconTypeID (string) (string)
2760 if len("$type") > 1000000 {
2761 return xerrors.Errorf("Value in field \"$type\" was too long")
2762 }
2763
2764 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2765 return err
2766 }
2767 if _, err := cw.WriteString(string("$type")); err != nil {
2768 return err
2769 }
2770
2771 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot.member"))); err != nil {
2772 return err
2773 }
2774 if _, err := cw.WriteString(string("sh.tangled.knot.member")); err != nil {
2775 return err
2776 }
2777
2778 // t.Domain (string) (string)
2779 if len("domain") > 1000000 {
2780 return xerrors.Errorf("Value in field \"domain\" was too long")
2781 }
2782
2783 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("domain"))); err != nil {
2784 return err
2785 }
2786 if _, err := cw.WriteString(string("domain")); err != nil {
2787 return err
2788 }
2789
2790 if len(t.Domain) > 1000000 {
2791 return xerrors.Errorf("Value in field t.Domain was too long")
2792 }
2793
2794 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Domain))); err != nil {
2795 return err
2796 }
2797 if _, err := cw.WriteString(string(t.Domain)); err != nil {
2798 return err
2799 }
2800
2801 // t.Subject (string) (string)
2802 if len("subject") > 1000000 {
2803 return xerrors.Errorf("Value in field \"subject\" was too long")
2804 }
2805
2806 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
2807 return err
2808 }
2809 if _, err := cw.WriteString(string("subject")); err != nil {
2810 return err
2811 }
2812
2813 if len(t.Subject) > 1000000 {
2814 return xerrors.Errorf("Value in field t.Subject was too long")
2815 }
2816
2817 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
2818 return err
2819 }
2820 if _, err := cw.WriteString(string(t.Subject)); err != nil {
2821 return err
2822 }
2823
2824 // t.CreatedAt (string) (string)
2825 if len("createdAt") > 1000000 {
2826 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2827 }
2828
2829 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2830 return err
2831 }
2832 if _, err := cw.WriteString(string("createdAt")); err != nil {
2833 return err
2834 }
2835
2836 if len(t.CreatedAt) > 1000000 {
2837 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2838 }
2839
2840 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2841 return err
2842 }
2843 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2844 return err
2845 }
2846 return nil
2847}
2848
2849func (t *KnotMember) UnmarshalCBOR(r io.Reader) (err error) {
2850 *t = KnotMember{}
2851
2852 cr := cbg.NewCborReader(r)
2853
2854 maj, extra, err := cr.ReadHeader()
2855 if err != nil {
2856 return err
2857 }
2858 defer func() {
2859 if err == io.EOF {
2860 err = io.ErrUnexpectedEOF
2861 }
2862 }()
2863
2864 if maj != cbg.MajMap {
2865 return fmt.Errorf("cbor input should be of type map")
2866 }
2867
2868 if extra > cbg.MaxLength {
2869 return fmt.Errorf("KnotMember: map struct too large (%d)", extra)
2870 }
2871
2872 n := extra
2873
2874 nameBuf := make([]byte, 9)
2875 for i := uint64(0); i < n; i++ {
2876 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2877 if err != nil {
2878 return err
2879 }
2880
2881 if !ok {
2882 // Field doesn't exist on this type, so ignore it
2883 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2884 return err
2885 }
2886 continue
2887 }
2888
2889 switch string(nameBuf[:nameLen]) {
2890 // t.LexiconTypeID (string) (string)
2891 case "$type":
2892
2893 {
2894 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2895 if err != nil {
2896 return err
2897 }
2898
2899 t.LexiconTypeID = string(sval)
2900 }
2901 // t.Domain (string) (string)
2902 case "domain":
2903
2904 {
2905 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2906 if err != nil {
2907 return err
2908 }
2909
2910 t.Domain = string(sval)
2911 }
2912 // t.Subject (string) (string)
2913 case "subject":
2914
2915 {
2916 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2917 if err != nil {
2918 return err
2919 }
2920
2921 t.Subject = string(sval)
2922 }
2923 // t.CreatedAt (string) (string)
2924 case "createdAt":
2925
2926 {
2927 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2928 if err != nil {
2929 return err
2930 }
2931
2932 t.CreatedAt = string(sval)
2933 }
2934
2935 default:
2936 // Field doesn't exist on this type, so ignore it
2937 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2938 return err
2939 }
2940 }
2941 }
2942
2943 return nil
2944}
2945func (t *LabelDefinition) MarshalCBOR(w io.Writer) error {
2946 if t == nil {
2947 _, err := w.Write(cbg.CborNull)
2948 return err
2949 }
2950
2951 cw := cbg.NewCborWriter(w)
2952 fieldCount := 7
2953
2954 if t.Color == nil {
2955 fieldCount--
2956 }
2957
2958 if t.Multiple == nil {
2959 fieldCount--
2960 }
2961
2962 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2963 return err
2964 }
2965
2966 // t.Name (string) (string)
2967 if len("name") > 1000000 {
2968 return xerrors.Errorf("Value in field \"name\" was too long")
2969 }
2970
2971 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
2972 return err
2973 }
2974 if _, err := cw.WriteString(string("name")); err != nil {
2975 return err
2976 }
2977
2978 if len(t.Name) > 1000000 {
2979 return xerrors.Errorf("Value in field t.Name was too long")
2980 }
2981
2982 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
2983 return err
2984 }
2985 if _, err := cw.WriteString(string(t.Name)); err != nil {
2986 return err
2987 }
2988
2989 // t.LexiconTypeID (string) (string)
2990 if len("$type") > 1000000 {
2991 return xerrors.Errorf("Value in field \"$type\" was too long")
2992 }
2993
2994 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2995 return err
2996 }
2997 if _, err := cw.WriteString(string("$type")); err != nil {
2998 return err
2999 }
3000
3001 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.definition"))); err != nil {
3002 return err
3003 }
3004 if _, err := cw.WriteString(string("sh.tangled.label.definition")); err != nil {
3005 return err
3006 }
3007
3008 // t.Color (string) (string)
3009 if t.Color != nil {
3010
3011 if len("color") > 1000000 {
3012 return xerrors.Errorf("Value in field \"color\" was too long")
3013 }
3014
3015 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("color"))); err != nil {
3016 return err
3017 }
3018 if _, err := cw.WriteString(string("color")); err != nil {
3019 return err
3020 }
3021
3022 if t.Color == nil {
3023 if _, err := cw.Write(cbg.CborNull); err != nil {
3024 return err
3025 }
3026 } else {
3027 if len(*t.Color) > 1000000 {
3028 return xerrors.Errorf("Value in field t.Color was too long")
3029 }
3030
3031 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Color))); err != nil {
3032 return err
3033 }
3034 if _, err := cw.WriteString(string(*t.Color)); err != nil {
3035 return err
3036 }
3037 }
3038 }
3039
3040 // t.Scope ([]string) (slice)
3041 if len("scope") > 1000000 {
3042 return xerrors.Errorf("Value in field \"scope\" was too long")
3043 }
3044
3045 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("scope"))); err != nil {
3046 return err
3047 }
3048 if _, err := cw.WriteString(string("scope")); err != nil {
3049 return err
3050 }
3051
3052 if len(t.Scope) > 8192 {
3053 return xerrors.Errorf("Slice value in field t.Scope was too long")
3054 }
3055
3056 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Scope))); err != nil {
3057 return err
3058 }
3059 for _, v := range t.Scope {
3060 if len(v) > 1000000 {
3061 return xerrors.Errorf("Value in field v was too long")
3062 }
3063
3064 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
3065 return err
3066 }
3067 if _, err := cw.WriteString(string(v)); err != nil {
3068 return err
3069 }
3070
3071 }
3072
3073 // t.Multiple (bool) (bool)
3074 if t.Multiple != nil {
3075
3076 if len("multiple") > 1000000 {
3077 return xerrors.Errorf("Value in field \"multiple\" was too long")
3078 }
3079
3080 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("multiple"))); err != nil {
3081 return err
3082 }
3083 if _, err := cw.WriteString(string("multiple")); err != nil {
3084 return err
3085 }
3086
3087 if t.Multiple == nil {
3088 if _, err := cw.Write(cbg.CborNull); err != nil {
3089 return err
3090 }
3091 } else {
3092 if err := cbg.WriteBool(w, *t.Multiple); err != nil {
3093 return err
3094 }
3095 }
3096 }
3097
3098 // t.CreatedAt (string) (string)
3099 if len("createdAt") > 1000000 {
3100 return xerrors.Errorf("Value in field \"createdAt\" was too long")
3101 }
3102
3103 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
3104 return err
3105 }
3106 if _, err := cw.WriteString(string("createdAt")); err != nil {
3107 return err
3108 }
3109
3110 if len(t.CreatedAt) > 1000000 {
3111 return xerrors.Errorf("Value in field t.CreatedAt was too long")
3112 }
3113
3114 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
3115 return err
3116 }
3117 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
3118 return err
3119 }
3120
3121 // t.ValueType (tangled.LabelDefinition_ValueType) (struct)
3122 if len("valueType") > 1000000 {
3123 return xerrors.Errorf("Value in field \"valueType\" was too long")
3124 }
3125
3126 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("valueType"))); err != nil {
3127 return err
3128 }
3129 if _, err := cw.WriteString(string("valueType")); err != nil {
3130 return err
3131 }
3132
3133 if err := t.ValueType.MarshalCBOR(cw); err != nil {
3134 return err
3135 }
3136 return nil
3137}
3138
3139func (t *LabelDefinition) UnmarshalCBOR(r io.Reader) (err error) {
3140 *t = LabelDefinition{}
3141
3142 cr := cbg.NewCborReader(r)
3143
3144 maj, extra, err := cr.ReadHeader()
3145 if err != nil {
3146 return err
3147 }
3148 defer func() {
3149 if err == io.EOF {
3150 err = io.ErrUnexpectedEOF
3151 }
3152 }()
3153
3154 if maj != cbg.MajMap {
3155 return fmt.Errorf("cbor input should be of type map")
3156 }
3157
3158 if extra > cbg.MaxLength {
3159 return fmt.Errorf("LabelDefinition: map struct too large (%d)", extra)
3160 }
3161
3162 n := extra
3163
3164 nameBuf := make([]byte, 9)
3165 for i := uint64(0); i < n; i++ {
3166 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3167 if err != nil {
3168 return err
3169 }
3170
3171 if !ok {
3172 // Field doesn't exist on this type, so ignore it
3173 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3174 return err
3175 }
3176 continue
3177 }
3178
3179 switch string(nameBuf[:nameLen]) {
3180 // t.Name (string) (string)
3181 case "name":
3182
3183 {
3184 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3185 if err != nil {
3186 return err
3187 }
3188
3189 t.Name = string(sval)
3190 }
3191 // t.LexiconTypeID (string) (string)
3192 case "$type":
3193
3194 {
3195 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3196 if err != nil {
3197 return err
3198 }
3199
3200 t.LexiconTypeID = string(sval)
3201 }
3202 // t.Color (string) (string)
3203 case "color":
3204
3205 {
3206 b, err := cr.ReadByte()
3207 if err != nil {
3208 return err
3209 }
3210 if b != cbg.CborNull[0] {
3211 if err := cr.UnreadByte(); err != nil {
3212 return err
3213 }
3214
3215 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3216 if err != nil {
3217 return err
3218 }
3219
3220 t.Color = (*string)(&sval)
3221 }
3222 }
3223 // t.Scope ([]string) (slice)
3224 case "scope":
3225
3226 maj, extra, err = cr.ReadHeader()
3227 if err != nil {
3228 return err
3229 }
3230
3231 if extra > 8192 {
3232 return fmt.Errorf("t.Scope: array too large (%d)", extra)
3233 }
3234
3235 if maj != cbg.MajArray {
3236 return fmt.Errorf("expected cbor array")
3237 }
3238
3239 if extra > 0 {
3240 t.Scope = make([]string, extra)
3241 }
3242
3243 for i := 0; i < int(extra); i++ {
3244 {
3245 var maj byte
3246 var extra uint64
3247 var err error
3248 _ = maj
3249 _ = extra
3250 _ = err
3251
3252 {
3253 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3254 if err != nil {
3255 return err
3256 }
3257
3258 t.Scope[i] = string(sval)
3259 }
3260
3261 }
3262 }
3263 // t.Multiple (bool) (bool)
3264 case "multiple":
3265
3266 {
3267 b, err := cr.ReadByte()
3268 if err != nil {
3269 return err
3270 }
3271 if b != cbg.CborNull[0] {
3272 if err := cr.UnreadByte(); err != nil {
3273 return err
3274 }
3275
3276 maj, extra, err = cr.ReadHeader()
3277 if err != nil {
3278 return err
3279 }
3280 if maj != cbg.MajOther {
3281 return fmt.Errorf("booleans must be major type 7")
3282 }
3283
3284 var val bool
3285 switch extra {
3286 case 20:
3287 val = false
3288 case 21:
3289 val = true
3290 default:
3291 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
3292 }
3293 t.Multiple = &val
3294 }
3295 }
3296 // t.CreatedAt (string) (string)
3297 case "createdAt":
3298
3299 {
3300 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3301 if err != nil {
3302 return err
3303 }
3304
3305 t.CreatedAt = string(sval)
3306 }
3307 // t.ValueType (tangled.LabelDefinition_ValueType) (struct)
3308 case "valueType":
3309
3310 {
3311
3312 b, err := cr.ReadByte()
3313 if err != nil {
3314 return err
3315 }
3316 if b != cbg.CborNull[0] {
3317 if err := cr.UnreadByte(); err != nil {
3318 return err
3319 }
3320 t.ValueType = new(LabelDefinition_ValueType)
3321 if err := t.ValueType.UnmarshalCBOR(cr); err != nil {
3322 return xerrors.Errorf("unmarshaling t.ValueType pointer: %w", err)
3323 }
3324 }
3325
3326 }
3327
3328 default:
3329 // Field doesn't exist on this type, so ignore it
3330 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3331 return err
3332 }
3333 }
3334 }
3335
3336 return nil
3337}
3338func (t *LabelDefinition_ValueType) MarshalCBOR(w io.Writer) error {
3339 if t == nil {
3340 _, err := w.Write(cbg.CborNull)
3341 return err
3342 }
3343
3344 cw := cbg.NewCborWriter(w)
3345 fieldCount := 3
3346
3347 if t.Enum == nil {
3348 fieldCount--
3349 }
3350
3351 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3352 return err
3353 }
3354
3355 // t.Enum ([]string) (slice)
3356 if t.Enum != nil {
3357
3358 if len("enum") > 1000000 {
3359 return xerrors.Errorf("Value in field \"enum\" was too long")
3360 }
3361
3362 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("enum"))); err != nil {
3363 return err
3364 }
3365 if _, err := cw.WriteString(string("enum")); err != nil {
3366 return err
3367 }
3368
3369 if len(t.Enum) > 8192 {
3370 return xerrors.Errorf("Slice value in field t.Enum was too long")
3371 }
3372
3373 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Enum))); err != nil {
3374 return err
3375 }
3376 for _, v := range t.Enum {
3377 if len(v) > 1000000 {
3378 return xerrors.Errorf("Value in field v was too long")
3379 }
3380
3381 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
3382 return err
3383 }
3384 if _, err := cw.WriteString(string(v)); err != nil {
3385 return err
3386 }
3387
3388 }
3389 }
3390
3391 // t.Type (string) (string)
3392 if len("type") > 1000000 {
3393 return xerrors.Errorf("Value in field \"type\" was too long")
3394 }
3395
3396 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("type"))); err != nil {
3397 return err
3398 }
3399 if _, err := cw.WriteString(string("type")); err != nil {
3400 return err
3401 }
3402
3403 if len(t.Type) > 1000000 {
3404 return xerrors.Errorf("Value in field t.Type was too long")
3405 }
3406
3407 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Type))); err != nil {
3408 return err
3409 }
3410 if _, err := cw.WriteString(string(t.Type)); err != nil {
3411 return err
3412 }
3413
3414 // t.Format (string) (string)
3415 if len("format") > 1000000 {
3416 return xerrors.Errorf("Value in field \"format\" was too long")
3417 }
3418
3419 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("format"))); err != nil {
3420 return err
3421 }
3422 if _, err := cw.WriteString(string("format")); err != nil {
3423 return err
3424 }
3425
3426 if len(t.Format) > 1000000 {
3427 return xerrors.Errorf("Value in field t.Format was too long")
3428 }
3429
3430 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Format))); err != nil {
3431 return err
3432 }
3433 if _, err := cw.WriteString(string(t.Format)); err != nil {
3434 return err
3435 }
3436 return nil
3437}
3438
3439func (t *LabelDefinition_ValueType) UnmarshalCBOR(r io.Reader) (err error) {
3440 *t = LabelDefinition_ValueType{}
3441
3442 cr := cbg.NewCborReader(r)
3443
3444 maj, extra, err := cr.ReadHeader()
3445 if err != nil {
3446 return err
3447 }
3448 defer func() {
3449 if err == io.EOF {
3450 err = io.ErrUnexpectedEOF
3451 }
3452 }()
3453
3454 if maj != cbg.MajMap {
3455 return fmt.Errorf("cbor input should be of type map")
3456 }
3457
3458 if extra > cbg.MaxLength {
3459 return fmt.Errorf("LabelDefinition_ValueType: map struct too large (%d)", extra)
3460 }
3461
3462 n := extra
3463
3464 nameBuf := make([]byte, 6)
3465 for i := uint64(0); i < n; i++ {
3466 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3467 if err != nil {
3468 return err
3469 }
3470
3471 if !ok {
3472 // Field doesn't exist on this type, so ignore it
3473 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3474 return err
3475 }
3476 continue
3477 }
3478
3479 switch string(nameBuf[:nameLen]) {
3480 // t.Enum ([]string) (slice)
3481 case "enum":
3482
3483 maj, extra, err = cr.ReadHeader()
3484 if err != nil {
3485 return err
3486 }
3487
3488 if extra > 8192 {
3489 return fmt.Errorf("t.Enum: array too large (%d)", extra)
3490 }
3491
3492 if maj != cbg.MajArray {
3493 return fmt.Errorf("expected cbor array")
3494 }
3495
3496 if extra > 0 {
3497 t.Enum = make([]string, extra)
3498 }
3499
3500 for i := 0; i < int(extra); i++ {
3501 {
3502 var maj byte
3503 var extra uint64
3504 var err error
3505 _ = maj
3506 _ = extra
3507 _ = err
3508
3509 {
3510 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3511 if err != nil {
3512 return err
3513 }
3514
3515 t.Enum[i] = string(sval)
3516 }
3517
3518 }
3519 }
3520 // t.Type (string) (string)
3521 case "type":
3522
3523 {
3524 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3525 if err != nil {
3526 return err
3527 }
3528
3529 t.Type = string(sval)
3530 }
3531 // t.Format (string) (string)
3532 case "format":
3533
3534 {
3535 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3536 if err != nil {
3537 return err
3538 }
3539
3540 t.Format = string(sval)
3541 }
3542
3543 default:
3544 // Field doesn't exist on this type, so ignore it
3545 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3546 return err
3547 }
3548 }
3549 }
3550
3551 return nil
3552}
3553func (t *LabelOp) MarshalCBOR(w io.Writer) error {
3554 if t == nil {
3555 _, err := w.Write(cbg.CborNull)
3556 return err
3557 }
3558
3559 cw := cbg.NewCborWriter(w)
3560
3561 if _, err := cw.Write([]byte{165}); err != nil {
3562 return err
3563 }
3564
3565 // t.Add ([]*tangled.LabelOp_Operand) (slice)
3566 if len("add") > 1000000 {
3567 return xerrors.Errorf("Value in field \"add\" was too long")
3568 }
3569
3570 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("add"))); err != nil {
3571 return err
3572 }
3573 if _, err := cw.WriteString(string("add")); err != nil {
3574 return err
3575 }
3576
3577 if len(t.Add) > 8192 {
3578 return xerrors.Errorf("Slice value in field t.Add was too long")
3579 }
3580
3581 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Add))); err != nil {
3582 return err
3583 }
3584 for _, v := range t.Add {
3585 if err := v.MarshalCBOR(cw); err != nil {
3586 return err
3587 }
3588
3589 }
3590
3591 // t.LexiconTypeID (string) (string)
3592 if len("$type") > 1000000 {
3593 return xerrors.Errorf("Value in field \"$type\" was too long")
3594 }
3595
3596 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3597 return err
3598 }
3599 if _, err := cw.WriteString(string("$type")); err != nil {
3600 return err
3601 }
3602
3603 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.op"))); err != nil {
3604 return err
3605 }
3606 if _, err := cw.WriteString(string("sh.tangled.label.op")); err != nil {
3607 return err
3608 }
3609
3610 // t.Delete ([]*tangled.LabelOp_Operand) (slice)
3611 if len("delete") > 1000000 {
3612 return xerrors.Errorf("Value in field \"delete\" was too long")
3613 }
3614
3615 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("delete"))); err != nil {
3616 return err
3617 }
3618 if _, err := cw.WriteString(string("delete")); err != nil {
3619 return err
3620 }
3621
3622 if len(t.Delete) > 8192 {
3623 return xerrors.Errorf("Slice value in field t.Delete was too long")
3624 }
3625
3626 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Delete))); err != nil {
3627 return err
3628 }
3629 for _, v := range t.Delete {
3630 if err := v.MarshalCBOR(cw); err != nil {
3631 return err
3632 }
3633
3634 }
3635
3636 // t.Subject (string) (string)
3637 if len("subject") > 1000000 {
3638 return xerrors.Errorf("Value in field \"subject\" was too long")
3639 }
3640
3641 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
3642 return err
3643 }
3644 if _, err := cw.WriteString(string("subject")); err != nil {
3645 return err
3646 }
3647
3648 if len(t.Subject) > 1000000 {
3649 return xerrors.Errorf("Value in field t.Subject was too long")
3650 }
3651
3652 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
3653 return err
3654 }
3655 if _, err := cw.WriteString(string(t.Subject)); err != nil {
3656 return err
3657 }
3658
3659 // t.PerformedAt (string) (string)
3660 if len("performedAt") > 1000000 {
3661 return xerrors.Errorf("Value in field \"performedAt\" was too long")
3662 }
3663
3664 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("performedAt"))); err != nil {
3665 return err
3666 }
3667 if _, err := cw.WriteString(string("performedAt")); err != nil {
3668 return err
3669 }
3670
3671 if len(t.PerformedAt) > 1000000 {
3672 return xerrors.Errorf("Value in field t.PerformedAt was too long")
3673 }
3674
3675 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.PerformedAt))); err != nil {
3676 return err
3677 }
3678 if _, err := cw.WriteString(string(t.PerformedAt)); err != nil {
3679 return err
3680 }
3681 return nil
3682}
3683
3684func (t *LabelOp) UnmarshalCBOR(r io.Reader) (err error) {
3685 *t = LabelOp{}
3686
3687 cr := cbg.NewCborReader(r)
3688
3689 maj, extra, err := cr.ReadHeader()
3690 if err != nil {
3691 return err
3692 }
3693 defer func() {
3694 if err == io.EOF {
3695 err = io.ErrUnexpectedEOF
3696 }
3697 }()
3698
3699 if maj != cbg.MajMap {
3700 return fmt.Errorf("cbor input should be of type map")
3701 }
3702
3703 if extra > cbg.MaxLength {
3704 return fmt.Errorf("LabelOp: map struct too large (%d)", extra)
3705 }
3706
3707 n := extra
3708
3709 nameBuf := make([]byte, 11)
3710 for i := uint64(0); i < n; i++ {
3711 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3712 if err != nil {
3713 return err
3714 }
3715
3716 if !ok {
3717 // Field doesn't exist on this type, so ignore it
3718 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3719 return err
3720 }
3721 continue
3722 }
3723
3724 switch string(nameBuf[:nameLen]) {
3725 // t.Add ([]*tangled.LabelOp_Operand) (slice)
3726 case "add":
3727
3728 maj, extra, err = cr.ReadHeader()
3729 if err != nil {
3730 return err
3731 }
3732
3733 if extra > 8192 {
3734 return fmt.Errorf("t.Add: array too large (%d)", extra)
3735 }
3736
3737 if maj != cbg.MajArray {
3738 return fmt.Errorf("expected cbor array")
3739 }
3740
3741 if extra > 0 {
3742 t.Add = make([]*LabelOp_Operand, extra)
3743 }
3744
3745 for i := 0; i < int(extra); i++ {
3746 {
3747 var maj byte
3748 var extra uint64
3749 var err error
3750 _ = maj
3751 _ = extra
3752 _ = err
3753
3754 {
3755
3756 b, err := cr.ReadByte()
3757 if err != nil {
3758 return err
3759 }
3760 if b != cbg.CborNull[0] {
3761 if err := cr.UnreadByte(); err != nil {
3762 return err
3763 }
3764 t.Add[i] = new(LabelOp_Operand)
3765 if err := t.Add[i].UnmarshalCBOR(cr); err != nil {
3766 return xerrors.Errorf("unmarshaling t.Add[i] pointer: %w", err)
3767 }
3768 }
3769
3770 }
3771
3772 }
3773 }
3774 // t.LexiconTypeID (string) (string)
3775 case "$type":
3776
3777 {
3778 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3779 if err != nil {
3780 return err
3781 }
3782
3783 t.LexiconTypeID = string(sval)
3784 }
3785 // t.Delete ([]*tangled.LabelOp_Operand) (slice)
3786 case "delete":
3787
3788 maj, extra, err = cr.ReadHeader()
3789 if err != nil {
3790 return err
3791 }
3792
3793 if extra > 8192 {
3794 return fmt.Errorf("t.Delete: array too large (%d)", extra)
3795 }
3796
3797 if maj != cbg.MajArray {
3798 return fmt.Errorf("expected cbor array")
3799 }
3800
3801 if extra > 0 {
3802 t.Delete = make([]*LabelOp_Operand, extra)
3803 }
3804
3805 for i := 0; i < int(extra); i++ {
3806 {
3807 var maj byte
3808 var extra uint64
3809 var err error
3810 _ = maj
3811 _ = extra
3812 _ = err
3813
3814 {
3815
3816 b, err := cr.ReadByte()
3817 if err != nil {
3818 return err
3819 }
3820 if b != cbg.CborNull[0] {
3821 if err := cr.UnreadByte(); err != nil {
3822 return err
3823 }
3824 t.Delete[i] = new(LabelOp_Operand)
3825 if err := t.Delete[i].UnmarshalCBOR(cr); err != nil {
3826 return xerrors.Errorf("unmarshaling t.Delete[i] pointer: %w", err)
3827 }
3828 }
3829
3830 }
3831
3832 }
3833 }
3834 // t.Subject (string) (string)
3835 case "subject":
3836
3837 {
3838 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3839 if err != nil {
3840 return err
3841 }
3842
3843 t.Subject = string(sval)
3844 }
3845 // t.PerformedAt (string) (string)
3846 case "performedAt":
3847
3848 {
3849 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3850 if err != nil {
3851 return err
3852 }
3853
3854 t.PerformedAt = string(sval)
3855 }
3856
3857 default:
3858 // Field doesn't exist on this type, so ignore it
3859 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3860 return err
3861 }
3862 }
3863 }
3864
3865 return nil
3866}
3867func (t *LabelOp_Operand) MarshalCBOR(w io.Writer) error {
3868 if t == nil {
3869 _, err := w.Write(cbg.CborNull)
3870 return err
3871 }
3872
3873 cw := cbg.NewCborWriter(w)
3874
3875 if _, err := cw.Write([]byte{162}); err != nil {
3876 return err
3877 }
3878
3879 // t.Key (string) (string)
3880 if len("key") > 1000000 {
3881 return xerrors.Errorf("Value in field \"key\" was too long")
3882 }
3883
3884 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
3885 return err
3886 }
3887 if _, err := cw.WriteString(string("key")); err != nil {
3888 return err
3889 }
3890
3891 if len(t.Key) > 1000000 {
3892 return xerrors.Errorf("Value in field t.Key was too long")
3893 }
3894
3895 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
3896 return err
3897 }
3898 if _, err := cw.WriteString(string(t.Key)); err != nil {
3899 return err
3900 }
3901
3902 // t.Value (string) (string)
3903 if len("value") > 1000000 {
3904 return xerrors.Errorf("Value in field \"value\" was too long")
3905 }
3906
3907 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
3908 return err
3909 }
3910 if _, err := cw.WriteString(string("value")); err != nil {
3911 return err
3912 }
3913
3914 if len(t.Value) > 1000000 {
3915 return xerrors.Errorf("Value in field t.Value was too long")
3916 }
3917
3918 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
3919 return err
3920 }
3921 if _, err := cw.WriteString(string(t.Value)); err != nil {
3922 return err
3923 }
3924 return nil
3925}
3926
3927func (t *LabelOp_Operand) UnmarshalCBOR(r io.Reader) (err error) {
3928 *t = LabelOp_Operand{}
3929
3930 cr := cbg.NewCborReader(r)
3931
3932 maj, extra, err := cr.ReadHeader()
3933 if err != nil {
3934 return err
3935 }
3936 defer func() {
3937 if err == io.EOF {
3938 err = io.ErrUnexpectedEOF
3939 }
3940 }()
3941
3942 if maj != cbg.MajMap {
3943 return fmt.Errorf("cbor input should be of type map")
3944 }
3945
3946 if extra > cbg.MaxLength {
3947 return fmt.Errorf("LabelOp_Operand: map struct too large (%d)", extra)
3948 }
3949
3950 n := extra
3951
3952 nameBuf := make([]byte, 5)
3953 for i := uint64(0); i < n; i++ {
3954 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3955 if err != nil {
3956 return err
3957 }
3958
3959 if !ok {
3960 // Field doesn't exist on this type, so ignore it
3961 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3962 return err
3963 }
3964 continue
3965 }
3966
3967 switch string(nameBuf[:nameLen]) {
3968 // t.Key (string) (string)
3969 case "key":
3970
3971 {
3972 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3973 if err != nil {
3974 return err
3975 }
3976
3977 t.Key = string(sval)
3978 }
3979 // t.Value (string) (string)
3980 case "value":
3981
3982 {
3983 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3984 if err != nil {
3985 return err
3986 }
3987
3988 t.Value = string(sval)
3989 }
3990
3991 default:
3992 // Field doesn't exist on this type, so ignore it
3993 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3994 return err
3995 }
3996 }
3997 }
3998
3999 return nil
4000}
4001func (t *Pipeline) MarshalCBOR(w io.Writer) error {
4002 if t == nil {
4003 _, err := w.Write(cbg.CborNull)
4004 return err
4005 }
4006
4007 cw := cbg.NewCborWriter(w)
4008
4009 if _, err := cw.Write([]byte{163}); err != nil {
4010 return err
4011 }
4012
4013 // t.LexiconTypeID (string) (string)
4014 if len("$type") > 1000000 {
4015 return xerrors.Errorf("Value in field \"$type\" was too long")
4016 }
4017
4018 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
4019 return err
4020 }
4021 if _, err := cw.WriteString(string("$type")); err != nil {
4022 return err
4023 }
4024
4025 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil {
4026 return err
4027 }
4028 if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil {
4029 return err
4030 }
4031
4032 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
4033 if len("workflows") > 1000000 {
4034 return xerrors.Errorf("Value in field \"workflows\" was too long")
4035 }
4036
4037 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil {
4038 return err
4039 }
4040 if _, err := cw.WriteString(string("workflows")); err != nil {
4041 return err
4042 }
4043
4044 if len(t.Workflows) > 8192 {
4045 return xerrors.Errorf("Slice value in field t.Workflows was too long")
4046 }
4047
4048 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil {
4049 return err
4050 }
4051 for _, v := range t.Workflows {
4052 if err := v.MarshalCBOR(cw); err != nil {
4053 return err
4054 }
4055
4056 }
4057
4058 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
4059 if len("triggerMetadata") > 1000000 {
4060 return xerrors.Errorf("Value in field \"triggerMetadata\" was too long")
4061 }
4062
4063 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil {
4064 return err
4065 }
4066 if _, err := cw.WriteString(string("triggerMetadata")); err != nil {
4067 return err
4068 }
4069
4070 if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil {
4071 return err
4072 }
4073 return nil
4074}
4075
4076func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) {
4077 *t = Pipeline{}
4078
4079 cr := cbg.NewCborReader(r)
4080
4081 maj, extra, err := cr.ReadHeader()
4082 if err != nil {
4083 return err
4084 }
4085 defer func() {
4086 if err == io.EOF {
4087 err = io.ErrUnexpectedEOF
4088 }
4089 }()
4090
4091 if maj != cbg.MajMap {
4092 return fmt.Errorf("cbor input should be of type map")
4093 }
4094
4095 if extra > cbg.MaxLength {
4096 return fmt.Errorf("Pipeline: map struct too large (%d)", extra)
4097 }
4098
4099 n := extra
4100
4101 nameBuf := make([]byte, 15)
4102 for i := uint64(0); i < n; i++ {
4103 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4104 if err != nil {
4105 return err
4106 }
4107
4108 if !ok {
4109 // Field doesn't exist on this type, so ignore it
4110 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4111 return err
4112 }
4113 continue
4114 }
4115
4116 switch string(nameBuf[:nameLen]) {
4117 // t.LexiconTypeID (string) (string)
4118 case "$type":
4119
4120 {
4121 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4122 if err != nil {
4123 return err
4124 }
4125
4126 t.LexiconTypeID = string(sval)
4127 }
4128 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
4129 case "workflows":
4130
4131 maj, extra, err = cr.ReadHeader()
4132 if err != nil {
4133 return err
4134 }
4135
4136 if extra > 8192 {
4137 return fmt.Errorf("t.Workflows: array too large (%d)", extra)
4138 }
4139
4140 if maj != cbg.MajArray {
4141 return fmt.Errorf("expected cbor array")
4142 }
4143
4144 if extra > 0 {
4145 t.Workflows = make([]*Pipeline_Workflow, extra)
4146 }
4147
4148 for i := 0; i < int(extra); i++ {
4149 {
4150 var maj byte
4151 var extra uint64
4152 var err error
4153 _ = maj
4154 _ = extra
4155 _ = err
4156
4157 {
4158
4159 b, err := cr.ReadByte()
4160 if err != nil {
4161 return err
4162 }
4163 if b != cbg.CborNull[0] {
4164 if err := cr.UnreadByte(); err != nil {
4165 return err
4166 }
4167 t.Workflows[i] = new(Pipeline_Workflow)
4168 if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil {
4169 return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err)
4170 }
4171 }
4172
4173 }
4174
4175 }
4176 }
4177 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
4178 case "triggerMetadata":
4179
4180 {
4181
4182 b, err := cr.ReadByte()
4183 if err != nil {
4184 return err
4185 }
4186 if b != cbg.CborNull[0] {
4187 if err := cr.UnreadByte(); err != nil {
4188 return err
4189 }
4190 t.TriggerMetadata = new(Pipeline_TriggerMetadata)
4191 if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil {
4192 return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err)
4193 }
4194 }
4195
4196 }
4197
4198 default:
4199 // Field doesn't exist on this type, so ignore it
4200 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4201 return err
4202 }
4203 }
4204 }
4205
4206 return nil
4207}
4208func (t *Pipeline_CloneOpts) MarshalCBOR(w io.Writer) error {
4209 if t == nil {
4210 _, err := w.Write(cbg.CborNull)
4211 return err
4212 }
4213
4214 cw := cbg.NewCborWriter(w)
4215
4216 if _, err := cw.Write([]byte{163}); err != nil {
4217 return err
4218 }
4219
4220 // t.Skip (bool) (bool)
4221 if len("skip") > 1000000 {
4222 return xerrors.Errorf("Value in field \"skip\" was too long")
4223 }
4224
4225 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("skip"))); err != nil {
4226 return err
4227 }
4228 if _, err := cw.WriteString(string("skip")); err != nil {
4229 return err
4230 }
4231
4232 if err := cbg.WriteBool(w, t.Skip); err != nil {
4233 return err
4234 }
4235
4236 // t.Depth (int64) (int64)
4237 if len("depth") > 1000000 {
4238 return xerrors.Errorf("Value in field \"depth\" was too long")
4239 }
4240
4241 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("depth"))); err != nil {
4242 return err
4243 }
4244 if _, err := cw.WriteString(string("depth")); err != nil {
4245 return err
4246 }
4247
4248 if t.Depth >= 0 {
4249 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Depth)); err != nil {
4250 return err
4251 }
4252 } else {
4253 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Depth-1)); err != nil {
4254 return err
4255 }
4256 }
4257
4258 // t.Submodules (bool) (bool)
4259 if len("submodules") > 1000000 {
4260 return xerrors.Errorf("Value in field \"submodules\" was too long")
4261 }
4262
4263 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("submodules"))); err != nil {
4264 return err
4265 }
4266 if _, err := cw.WriteString(string("submodules")); err != nil {
4267 return err
4268 }
4269
4270 if err := cbg.WriteBool(w, t.Submodules); err != nil {
4271 return err
4272 }
4273 return nil
4274}
4275
4276func (t *Pipeline_CloneOpts) UnmarshalCBOR(r io.Reader) (err error) {
4277 *t = Pipeline_CloneOpts{}
4278
4279 cr := cbg.NewCborReader(r)
4280
4281 maj, extra, err := cr.ReadHeader()
4282 if err != nil {
4283 return err
4284 }
4285 defer func() {
4286 if err == io.EOF {
4287 err = io.ErrUnexpectedEOF
4288 }
4289 }()
4290
4291 if maj != cbg.MajMap {
4292 return fmt.Errorf("cbor input should be of type map")
4293 }
4294
4295 if extra > cbg.MaxLength {
4296 return fmt.Errorf("Pipeline_CloneOpts: map struct too large (%d)", extra)
4297 }
4298
4299 n := extra
4300
4301 nameBuf := make([]byte, 10)
4302 for i := uint64(0); i < n; i++ {
4303 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4304 if err != nil {
4305 return err
4306 }
4307
4308 if !ok {
4309 // Field doesn't exist on this type, so ignore it
4310 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4311 return err
4312 }
4313 continue
4314 }
4315
4316 switch string(nameBuf[:nameLen]) {
4317 // t.Skip (bool) (bool)
4318 case "skip":
4319
4320 maj, extra, err = cr.ReadHeader()
4321 if err != nil {
4322 return err
4323 }
4324 if maj != cbg.MajOther {
4325 return fmt.Errorf("booleans must be major type 7")
4326 }
4327 switch extra {
4328 case 20:
4329 t.Skip = false
4330 case 21:
4331 t.Skip = true
4332 default:
4333 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
4334 }
4335 // t.Depth (int64) (int64)
4336 case "depth":
4337 {
4338 maj, extra, err := cr.ReadHeader()
4339 if err != nil {
4340 return err
4341 }
4342 var extraI int64
4343 switch maj {
4344 case cbg.MajUnsignedInt:
4345 extraI = int64(extra)
4346 if extraI < 0 {
4347 return fmt.Errorf("int64 positive overflow")
4348 }
4349 case cbg.MajNegativeInt:
4350 extraI = int64(extra)
4351 if extraI < 0 {
4352 return fmt.Errorf("int64 negative overflow")
4353 }
4354 extraI = -1 - extraI
4355 default:
4356 return fmt.Errorf("wrong type for int64 field: %d", maj)
4357 }
4358
4359 t.Depth = int64(extraI)
4360 }
4361 // t.Submodules (bool) (bool)
4362 case "submodules":
4363
4364 maj, extra, err = cr.ReadHeader()
4365 if err != nil {
4366 return err
4367 }
4368 if maj != cbg.MajOther {
4369 return fmt.Errorf("booleans must be major type 7")
4370 }
4371 switch extra {
4372 case 20:
4373 t.Submodules = false
4374 case 21:
4375 t.Submodules = true
4376 default:
4377 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
4378 }
4379
4380 default:
4381 // Field doesn't exist on this type, so ignore it
4382 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4383 return err
4384 }
4385 }
4386 }
4387
4388 return nil
4389}
4390func (t *Pipeline_ManualTriggerData) MarshalCBOR(w io.Writer) error {
4391 if t == nil {
4392 _, err := w.Write(cbg.CborNull)
4393 return err
4394 }
4395
4396 cw := cbg.NewCborWriter(w)
4397 fieldCount := 1
4398
4399 if t.Inputs == nil {
4400 fieldCount--
4401 }
4402
4403 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4404 return err
4405 }
4406
4407 // t.Inputs ([]*tangled.Pipeline_Pair) (slice)
4408 if t.Inputs != nil {
4409
4410 if len("inputs") > 1000000 {
4411 return xerrors.Errorf("Value in field \"inputs\" was too long")
4412 }
4413
4414 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
4415 return err
4416 }
4417 if _, err := cw.WriteString(string("inputs")); err != nil {
4418 return err
4419 }
4420
4421 if len(t.Inputs) > 8192 {
4422 return xerrors.Errorf("Slice value in field t.Inputs was too long")
4423 }
4424
4425 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
4426 return err
4427 }
4428 for _, v := range t.Inputs {
4429 if err := v.MarshalCBOR(cw); err != nil {
4430 return err
4431 }
4432
4433 }
4434 }
4435 return nil
4436}
4437
4438func (t *Pipeline_ManualTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
4439 *t = Pipeline_ManualTriggerData{}
4440
4441 cr := cbg.NewCborReader(r)
4442
4443 maj, extra, err := cr.ReadHeader()
4444 if err != nil {
4445 return err
4446 }
4447 defer func() {
4448 if err == io.EOF {
4449 err = io.ErrUnexpectedEOF
4450 }
4451 }()
4452
4453 if maj != cbg.MajMap {
4454 return fmt.Errorf("cbor input should be of type map")
4455 }
4456
4457 if extra > cbg.MaxLength {
4458 return fmt.Errorf("Pipeline_ManualTriggerData: map struct too large (%d)", extra)
4459 }
4460
4461 n := extra
4462
4463 nameBuf := make([]byte, 6)
4464 for i := uint64(0); i < n; i++ {
4465 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4466 if err != nil {
4467 return err
4468 }
4469
4470 if !ok {
4471 // Field doesn't exist on this type, so ignore it
4472 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4473 return err
4474 }
4475 continue
4476 }
4477
4478 switch string(nameBuf[:nameLen]) {
4479 // t.Inputs ([]*tangled.Pipeline_Pair) (slice)
4480 case "inputs":
4481
4482 maj, extra, err = cr.ReadHeader()
4483 if err != nil {
4484 return err
4485 }
4486
4487 if extra > 8192 {
4488 return fmt.Errorf("t.Inputs: array too large (%d)", extra)
4489 }
4490
4491 if maj != cbg.MajArray {
4492 return fmt.Errorf("expected cbor array")
4493 }
4494
4495 if extra > 0 {
4496 t.Inputs = make([]*Pipeline_Pair, extra)
4497 }
4498
4499 for i := 0; i < int(extra); i++ {
4500 {
4501 var maj byte
4502 var extra uint64
4503 var err error
4504 _ = maj
4505 _ = extra
4506 _ = err
4507
4508 {
4509
4510 b, err := cr.ReadByte()
4511 if err != nil {
4512 return err
4513 }
4514 if b != cbg.CborNull[0] {
4515 if err := cr.UnreadByte(); err != nil {
4516 return err
4517 }
4518 t.Inputs[i] = new(Pipeline_Pair)
4519 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
4520 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
4521 }
4522 }
4523
4524 }
4525
4526 }
4527 }
4528
4529 default:
4530 // Field doesn't exist on this type, so ignore it
4531 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4532 return err
4533 }
4534 }
4535 }
4536
4537 return nil
4538}
4539func (t *Pipeline_Pair) MarshalCBOR(w io.Writer) error {
4540 if t == nil {
4541 _, err := w.Write(cbg.CborNull)
4542 return err
4543 }
4544
4545 cw := cbg.NewCborWriter(w)
4546
4547 if _, err := cw.Write([]byte{162}); err != nil {
4548 return err
4549 }
4550
4551 // t.Key (string) (string)
4552 if len("key") > 1000000 {
4553 return xerrors.Errorf("Value in field \"key\" was too long")
4554 }
4555
4556 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
4557 return err
4558 }
4559 if _, err := cw.WriteString(string("key")); err != nil {
4560 return err
4561 }
4562
4563 if len(t.Key) > 1000000 {
4564 return xerrors.Errorf("Value in field t.Key was too long")
4565 }
4566
4567 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
4568 return err
4569 }
4570 if _, err := cw.WriteString(string(t.Key)); err != nil {
4571 return err
4572 }
4573
4574 // t.Value (string) (string)
4575 if len("value") > 1000000 {
4576 return xerrors.Errorf("Value in field \"value\" was too long")
4577 }
4578
4579 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
4580 return err
4581 }
4582 if _, err := cw.WriteString(string("value")); err != nil {
4583 return err
4584 }
4585
4586 if len(t.Value) > 1000000 {
4587 return xerrors.Errorf("Value in field t.Value was too long")
4588 }
4589
4590 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
4591 return err
4592 }
4593 if _, err := cw.WriteString(string(t.Value)); err != nil {
4594 return err
4595 }
4596 return nil
4597}
4598
4599func (t *Pipeline_Pair) UnmarshalCBOR(r io.Reader) (err error) {
4600 *t = Pipeline_Pair{}
4601
4602 cr := cbg.NewCborReader(r)
4603
4604 maj, extra, err := cr.ReadHeader()
4605 if err != nil {
4606 return err
4607 }
4608 defer func() {
4609 if err == io.EOF {
4610 err = io.ErrUnexpectedEOF
4611 }
4612 }()
4613
4614 if maj != cbg.MajMap {
4615 return fmt.Errorf("cbor input should be of type map")
4616 }
4617
4618 if extra > cbg.MaxLength {
4619 return fmt.Errorf("Pipeline_Pair: map struct too large (%d)", extra)
4620 }
4621
4622 n := extra
4623
4624 nameBuf := make([]byte, 5)
4625 for i := uint64(0); i < n; i++ {
4626 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4627 if err != nil {
4628 return err
4629 }
4630
4631 if !ok {
4632 // Field doesn't exist on this type, so ignore it
4633 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4634 return err
4635 }
4636 continue
4637 }
4638
4639 switch string(nameBuf[:nameLen]) {
4640 // t.Key (string) (string)
4641 case "key":
4642
4643 {
4644 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4645 if err != nil {
4646 return err
4647 }
4648
4649 t.Key = string(sval)
4650 }
4651 // t.Value (string) (string)
4652 case "value":
4653
4654 {
4655 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4656 if err != nil {
4657 return err
4658 }
4659
4660 t.Value = string(sval)
4661 }
4662
4663 default:
4664 // Field doesn't exist on this type, so ignore it
4665 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4666 return err
4667 }
4668 }
4669 }
4670
4671 return nil
4672}
4673func (t *Pipeline_PullRequestTriggerData) MarshalCBOR(w io.Writer) error {
4674 if t == nil {
4675 _, err := w.Write(cbg.CborNull)
4676 return err
4677 }
4678
4679 cw := cbg.NewCborWriter(w)
4680
4681 if _, err := cw.Write([]byte{164}); err != nil {
4682 return err
4683 }
4684
4685 // t.Action (string) (string)
4686 if len("action") > 1000000 {
4687 return xerrors.Errorf("Value in field \"action\" was too long")
4688 }
4689
4690 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("action"))); err != nil {
4691 return err
4692 }
4693 if _, err := cw.WriteString(string("action")); err != nil {
4694 return err
4695 }
4696
4697 if len(t.Action) > 1000000 {
4698 return xerrors.Errorf("Value in field t.Action was too long")
4699 }
4700
4701 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Action))); err != nil {
4702 return err
4703 }
4704 if _, err := cw.WriteString(string(t.Action)); err != nil {
4705 return err
4706 }
4707
4708 // t.SourceSha (string) (string)
4709 if len("sourceSha") > 1000000 {
4710 return xerrors.Errorf("Value in field \"sourceSha\" was too long")
4711 }
4712
4713 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceSha"))); err != nil {
4714 return err
4715 }
4716 if _, err := cw.WriteString(string("sourceSha")); err != nil {
4717 return err
4718 }
4719
4720 if len(t.SourceSha) > 1000000 {
4721 return xerrors.Errorf("Value in field t.SourceSha was too long")
4722 }
4723
4724 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceSha))); err != nil {
4725 return err
4726 }
4727 if _, err := cw.WriteString(string(t.SourceSha)); err != nil {
4728 return err
4729 }
4730
4731 // t.SourceBranch (string) (string)
4732 if len("sourceBranch") > 1000000 {
4733 return xerrors.Errorf("Value in field \"sourceBranch\" was too long")
4734 }
4735
4736 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceBranch"))); err != nil {
4737 return err
4738 }
4739 if _, err := cw.WriteString(string("sourceBranch")); err != nil {
4740 return err
4741 }
4742
4743 if len(t.SourceBranch) > 1000000 {
4744 return xerrors.Errorf("Value in field t.SourceBranch was too long")
4745 }
4746
4747 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceBranch))); err != nil {
4748 return err
4749 }
4750 if _, err := cw.WriteString(string(t.SourceBranch)); err != nil {
4751 return err
4752 }
4753
4754 // t.TargetBranch (string) (string)
4755 if len("targetBranch") > 1000000 {
4756 return xerrors.Errorf("Value in field \"targetBranch\" was too long")
4757 }
4758
4759 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil {
4760 return err
4761 }
4762 if _, err := cw.WriteString(string("targetBranch")); err != nil {
4763 return err
4764 }
4765
4766 if len(t.TargetBranch) > 1000000 {
4767 return xerrors.Errorf("Value in field t.TargetBranch was too long")
4768 }
4769
4770 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil {
4771 return err
4772 }
4773 if _, err := cw.WriteString(string(t.TargetBranch)); err != nil {
4774 return err
4775 }
4776 return nil
4777}
4778
4779func (t *Pipeline_PullRequestTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
4780 *t = Pipeline_PullRequestTriggerData{}
4781
4782 cr := cbg.NewCborReader(r)
4783
4784 maj, extra, err := cr.ReadHeader()
4785 if err != nil {
4786 return err
4787 }
4788 defer func() {
4789 if err == io.EOF {
4790 err = io.ErrUnexpectedEOF
4791 }
4792 }()
4793
4794 if maj != cbg.MajMap {
4795 return fmt.Errorf("cbor input should be of type map")
4796 }
4797
4798 if extra > cbg.MaxLength {
4799 return fmt.Errorf("Pipeline_PullRequestTriggerData: map struct too large (%d)", extra)
4800 }
4801
4802 n := extra
4803
4804 nameBuf := make([]byte, 12)
4805 for i := uint64(0); i < n; i++ {
4806 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4807 if err != nil {
4808 return err
4809 }
4810
4811 if !ok {
4812 // Field doesn't exist on this type, so ignore it
4813 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4814 return err
4815 }
4816 continue
4817 }
4818
4819 switch string(nameBuf[:nameLen]) {
4820 // t.Action (string) (string)
4821 case "action":
4822
4823 {
4824 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4825 if err != nil {
4826 return err
4827 }
4828
4829 t.Action = string(sval)
4830 }
4831 // t.SourceSha (string) (string)
4832 case "sourceSha":
4833
4834 {
4835 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4836 if err != nil {
4837 return err
4838 }
4839
4840 t.SourceSha = string(sval)
4841 }
4842 // t.SourceBranch (string) (string)
4843 case "sourceBranch":
4844
4845 {
4846 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4847 if err != nil {
4848 return err
4849 }
4850
4851 t.SourceBranch = string(sval)
4852 }
4853 // t.TargetBranch (string) (string)
4854 case "targetBranch":
4855
4856 {
4857 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4858 if err != nil {
4859 return err
4860 }
4861
4862 t.TargetBranch = string(sval)
4863 }
4864
4865 default:
4866 // Field doesn't exist on this type, so ignore it
4867 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4868 return err
4869 }
4870 }
4871 }
4872
4873 return nil
4874}
4875func (t *Pipeline_PushTriggerData) MarshalCBOR(w io.Writer) error {
4876 if t == nil {
4877 _, err := w.Write(cbg.CborNull)
4878 return err
4879 }
4880
4881 cw := cbg.NewCborWriter(w)
4882
4883 if _, err := cw.Write([]byte{163}); err != nil {
4884 return err
4885 }
4886
4887 // t.Ref (string) (string)
4888 if len("ref") > 1000000 {
4889 return xerrors.Errorf("Value in field \"ref\" was too long")
4890 }
4891
4892 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
4893 return err
4894 }
4895 if _, err := cw.WriteString(string("ref")); err != nil {
4896 return err
4897 }
4898
4899 if len(t.Ref) > 1000000 {
4900 return xerrors.Errorf("Value in field t.Ref was too long")
4901 }
4902
4903 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
4904 return err
4905 }
4906 if _, err := cw.WriteString(string(t.Ref)); err != nil {
4907 return err
4908 }
4909
4910 // t.NewSha (string) (string)
4911 if len("newSha") > 1000000 {
4912 return xerrors.Errorf("Value in field \"newSha\" was too long")
4913 }
4914
4915 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
4916 return err
4917 }
4918 if _, err := cw.WriteString(string("newSha")); err != nil {
4919 return err
4920 }
4921
4922 if len(t.NewSha) > 1000000 {
4923 return xerrors.Errorf("Value in field t.NewSha was too long")
4924 }
4925
4926 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
4927 return err
4928 }
4929 if _, err := cw.WriteString(string(t.NewSha)); err != nil {
4930 return err
4931 }
4932
4933 // t.OldSha (string) (string)
4934 if len("oldSha") > 1000000 {
4935 return xerrors.Errorf("Value in field \"oldSha\" was too long")
4936 }
4937
4938 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
4939 return err
4940 }
4941 if _, err := cw.WriteString(string("oldSha")); err != nil {
4942 return err
4943 }
4944
4945 if len(t.OldSha) > 1000000 {
4946 return xerrors.Errorf("Value in field t.OldSha was too long")
4947 }
4948
4949 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
4950 return err
4951 }
4952 if _, err := cw.WriteString(string(t.OldSha)); err != nil {
4953 return err
4954 }
4955 return nil
4956}
4957
4958func (t *Pipeline_PushTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
4959 *t = Pipeline_PushTriggerData{}
4960
4961 cr := cbg.NewCborReader(r)
4962
4963 maj, extra, err := cr.ReadHeader()
4964 if err != nil {
4965 return err
4966 }
4967 defer func() {
4968 if err == io.EOF {
4969 err = io.ErrUnexpectedEOF
4970 }
4971 }()
4972
4973 if maj != cbg.MajMap {
4974 return fmt.Errorf("cbor input should be of type map")
4975 }
4976
4977 if extra > cbg.MaxLength {
4978 return fmt.Errorf("Pipeline_PushTriggerData: map struct too large (%d)", extra)
4979 }
4980
4981 n := extra
4982
4983 nameBuf := make([]byte, 6)
4984 for i := uint64(0); i < n; i++ {
4985 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4986 if err != nil {
4987 return err
4988 }
4989
4990 if !ok {
4991 // Field doesn't exist on this type, so ignore it
4992 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4993 return err
4994 }
4995 continue
4996 }
4997
4998 switch string(nameBuf[:nameLen]) {
4999 // t.Ref (string) (string)
5000 case "ref":
5001
5002 {
5003 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5004 if err != nil {
5005 return err
5006 }
5007
5008 t.Ref = string(sval)
5009 }
5010 // t.NewSha (string) (string)
5011 case "newSha":
5012
5013 {
5014 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5015 if err != nil {
5016 return err
5017 }
5018
5019 t.NewSha = string(sval)
5020 }
5021 // t.OldSha (string) (string)
5022 case "oldSha":
5023
5024 {
5025 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5026 if err != nil {
5027 return err
5028 }
5029
5030 t.OldSha = string(sval)
5031 }
5032
5033 default:
5034 // Field doesn't exist on this type, so ignore it
5035 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5036 return err
5037 }
5038 }
5039 }
5040
5041 return nil
5042}
5043func (t *PipelineStatus) MarshalCBOR(w io.Writer) error {
5044 if t == nil {
5045 _, err := w.Write(cbg.CborNull)
5046 return err
5047 }
5048
5049 cw := cbg.NewCborWriter(w)
5050 fieldCount := 7
5051
5052 if t.Error == nil {
5053 fieldCount--
5054 }
5055
5056 if t.ExitCode == nil {
5057 fieldCount--
5058 }
5059
5060 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5061 return err
5062 }
5063
5064 // t.LexiconTypeID (string) (string)
5065 if len("$type") > 1000000 {
5066 return xerrors.Errorf("Value in field \"$type\" was too long")
5067 }
5068
5069 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5070 return err
5071 }
5072 if _, err := cw.WriteString(string("$type")); err != nil {
5073 return err
5074 }
5075
5076 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline.status"))); err != nil {
5077 return err
5078 }
5079 if _, err := cw.WriteString(string("sh.tangled.pipeline.status")); err != nil {
5080 return err
5081 }
5082
5083 // t.Error (string) (string)
5084 if t.Error != nil {
5085
5086 if len("error") > 1000000 {
5087 return xerrors.Errorf("Value in field \"error\" was too long")
5088 }
5089
5090 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("error"))); err != nil {
5091 return err
5092 }
5093 if _, err := cw.WriteString(string("error")); err != nil {
5094 return err
5095 }
5096
5097 if t.Error == nil {
5098 if _, err := cw.Write(cbg.CborNull); err != nil {
5099 return err
5100 }
5101 } else {
5102 if len(*t.Error) > 1000000 {
5103 return xerrors.Errorf("Value in field t.Error was too long")
5104 }
5105
5106 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Error))); err != nil {
5107 return err
5108 }
5109 if _, err := cw.WriteString(string(*t.Error)); err != nil {
5110 return err
5111 }
5112 }
5113 }
5114
5115 // t.Status (string) (string)
5116 if len("status") > 1000000 {
5117 return xerrors.Errorf("Value in field \"status\" was too long")
5118 }
5119
5120 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
5121 return err
5122 }
5123 if _, err := cw.WriteString(string("status")); err != nil {
5124 return err
5125 }
5126
5127 if len(t.Status) > 1000000 {
5128 return xerrors.Errorf("Value in field t.Status was too long")
5129 }
5130
5131 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
5132 return err
5133 }
5134 if _, err := cw.WriteString(string(t.Status)); err != nil {
5135 return err
5136 }
5137
5138 // t.ExitCode (int64) (int64)
5139 if t.ExitCode != nil {
5140
5141 if len("exitCode") > 1000000 {
5142 return xerrors.Errorf("Value in field \"exitCode\" was too long")
5143 }
5144
5145 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("exitCode"))); err != nil {
5146 return err
5147 }
5148 if _, err := cw.WriteString(string("exitCode")); err != nil {
5149 return err
5150 }
5151
5152 if t.ExitCode == nil {
5153 if _, err := cw.Write(cbg.CborNull); err != nil {
5154 return err
5155 }
5156 } else {
5157 if *t.ExitCode >= 0 {
5158 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.ExitCode)); err != nil {
5159 return err
5160 }
5161 } else {
5162 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.ExitCode-1)); err != nil {
5163 return err
5164 }
5165 }
5166 }
5167
5168 }
5169
5170 // t.Pipeline (string) (string)
5171 if len("pipeline") > 1000000 {
5172 return xerrors.Errorf("Value in field \"pipeline\" was too long")
5173 }
5174
5175 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pipeline"))); err != nil {
5176 return err
5177 }
5178 if _, err := cw.WriteString(string("pipeline")); err != nil {
5179 return err
5180 }
5181
5182 if len(t.Pipeline) > 1000000 {
5183 return xerrors.Errorf("Value in field t.Pipeline was too long")
5184 }
5185
5186 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pipeline))); err != nil {
5187 return err
5188 }
5189 if _, err := cw.WriteString(string(t.Pipeline)); err != nil {
5190 return err
5191 }
5192
5193 // t.Workflow (string) (string)
5194 if len("workflow") > 1000000 {
5195 return xerrors.Errorf("Value in field \"workflow\" was too long")
5196 }
5197
5198 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil {
5199 return err
5200 }
5201 if _, err := cw.WriteString(string("workflow")); err != nil {
5202 return err
5203 }
5204
5205 if len(t.Workflow) > 1000000 {
5206 return xerrors.Errorf("Value in field t.Workflow was too long")
5207 }
5208
5209 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil {
5210 return err
5211 }
5212 if _, err := cw.WriteString(string(t.Workflow)); err != nil {
5213 return err
5214 }
5215
5216 // t.CreatedAt (string) (string)
5217 if len("createdAt") > 1000000 {
5218 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5219 }
5220
5221 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5222 return err
5223 }
5224 if _, err := cw.WriteString(string("createdAt")); err != nil {
5225 return err
5226 }
5227
5228 if len(t.CreatedAt) > 1000000 {
5229 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5230 }
5231
5232 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5233 return err
5234 }
5235 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5236 return err
5237 }
5238 return nil
5239}
5240
5241func (t *PipelineStatus) UnmarshalCBOR(r io.Reader) (err error) {
5242 *t = PipelineStatus{}
5243
5244 cr := cbg.NewCborReader(r)
5245
5246 maj, extra, err := cr.ReadHeader()
5247 if err != nil {
5248 return err
5249 }
5250 defer func() {
5251 if err == io.EOF {
5252 err = io.ErrUnexpectedEOF
5253 }
5254 }()
5255
5256 if maj != cbg.MajMap {
5257 return fmt.Errorf("cbor input should be of type map")
5258 }
5259
5260 if extra > cbg.MaxLength {
5261 return fmt.Errorf("PipelineStatus: map struct too large (%d)", extra)
5262 }
5263
5264 n := extra
5265
5266 nameBuf := make([]byte, 9)
5267 for i := uint64(0); i < n; i++ {
5268 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5269 if err != nil {
5270 return err
5271 }
5272
5273 if !ok {
5274 // Field doesn't exist on this type, so ignore it
5275 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5276 return err
5277 }
5278 continue
5279 }
5280
5281 switch string(nameBuf[:nameLen]) {
5282 // t.LexiconTypeID (string) (string)
5283 case "$type":
5284
5285 {
5286 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5287 if err != nil {
5288 return err
5289 }
5290
5291 t.LexiconTypeID = string(sval)
5292 }
5293 // t.Error (string) (string)
5294 case "error":
5295
5296 {
5297 b, err := cr.ReadByte()
5298 if err != nil {
5299 return err
5300 }
5301 if b != cbg.CborNull[0] {
5302 if err := cr.UnreadByte(); err != nil {
5303 return err
5304 }
5305
5306 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5307 if err != nil {
5308 return err
5309 }
5310
5311 t.Error = (*string)(&sval)
5312 }
5313 }
5314 // t.Status (string) (string)
5315 case "status":
5316
5317 {
5318 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5319 if err != nil {
5320 return err
5321 }
5322
5323 t.Status = string(sval)
5324 }
5325 // t.ExitCode (int64) (int64)
5326 case "exitCode":
5327 {
5328
5329 b, err := cr.ReadByte()
5330 if err != nil {
5331 return err
5332 }
5333 if b != cbg.CborNull[0] {
5334 if err := cr.UnreadByte(); err != nil {
5335 return err
5336 }
5337 maj, extra, err := cr.ReadHeader()
5338 if err != nil {
5339 return err
5340 }
5341 var extraI int64
5342 switch maj {
5343 case cbg.MajUnsignedInt:
5344 extraI = int64(extra)
5345 if extraI < 0 {
5346 return fmt.Errorf("int64 positive overflow")
5347 }
5348 case cbg.MajNegativeInt:
5349 extraI = int64(extra)
5350 if extraI < 0 {
5351 return fmt.Errorf("int64 negative overflow")
5352 }
5353 extraI = -1 - extraI
5354 default:
5355 return fmt.Errorf("wrong type for int64 field: %d", maj)
5356 }
5357
5358 t.ExitCode = (*int64)(&extraI)
5359 }
5360 }
5361 // t.Pipeline (string) (string)
5362 case "pipeline":
5363
5364 {
5365 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5366 if err != nil {
5367 return err
5368 }
5369
5370 t.Pipeline = string(sval)
5371 }
5372 // t.Workflow (string) (string)
5373 case "workflow":
5374
5375 {
5376 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5377 if err != nil {
5378 return err
5379 }
5380
5381 t.Workflow = string(sval)
5382 }
5383 // t.CreatedAt (string) (string)
5384 case "createdAt":
5385
5386 {
5387 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5388 if err != nil {
5389 return err
5390 }
5391
5392 t.CreatedAt = string(sval)
5393 }
5394
5395 default:
5396 // Field doesn't exist on this type, so ignore it
5397 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5398 return err
5399 }
5400 }
5401 }
5402
5403 return nil
5404}
5405func (t *Pipeline_TriggerMetadata) MarshalCBOR(w io.Writer) error {
5406 if t == nil {
5407 _, err := w.Write(cbg.CborNull)
5408 return err
5409 }
5410
5411 cw := cbg.NewCborWriter(w)
5412 fieldCount := 5
5413
5414 if t.Manual == nil {
5415 fieldCount--
5416 }
5417
5418 if t.PullRequest == nil {
5419 fieldCount--
5420 }
5421
5422 if t.Push == nil {
5423 fieldCount--
5424 }
5425
5426 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5427 return err
5428 }
5429
5430 // t.Kind (string) (string)
5431 if len("kind") > 1000000 {
5432 return xerrors.Errorf("Value in field \"kind\" was too long")
5433 }
5434
5435 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("kind"))); err != nil {
5436 return err
5437 }
5438 if _, err := cw.WriteString(string("kind")); err != nil {
5439 return err
5440 }
5441
5442 if len(t.Kind) > 1000000 {
5443 return xerrors.Errorf("Value in field t.Kind was too long")
5444 }
5445
5446 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Kind))); err != nil {
5447 return err
5448 }
5449 if _, err := cw.WriteString(string(t.Kind)); err != nil {
5450 return err
5451 }
5452
5453 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
5454 if t.Push != nil {
5455
5456 if len("push") > 1000000 {
5457 return xerrors.Errorf("Value in field \"push\" was too long")
5458 }
5459
5460 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("push"))); err != nil {
5461 return err
5462 }
5463 if _, err := cw.WriteString(string("push")); err != nil {
5464 return err
5465 }
5466
5467 if err := t.Push.MarshalCBOR(cw); err != nil {
5468 return err
5469 }
5470 }
5471
5472 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
5473 if len("repo") > 1000000 {
5474 return xerrors.Errorf("Value in field \"repo\" was too long")
5475 }
5476
5477 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5478 return err
5479 }
5480 if _, err := cw.WriteString(string("repo")); err != nil {
5481 return err
5482 }
5483
5484 if err := t.Repo.MarshalCBOR(cw); err != nil {
5485 return err
5486 }
5487
5488 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
5489 if t.Manual != nil {
5490
5491 if len("manual") > 1000000 {
5492 return xerrors.Errorf("Value in field \"manual\" was too long")
5493 }
5494
5495 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("manual"))); err != nil {
5496 return err
5497 }
5498 if _, err := cw.WriteString(string("manual")); err != nil {
5499 return err
5500 }
5501
5502 if err := t.Manual.MarshalCBOR(cw); err != nil {
5503 return err
5504 }
5505 }
5506
5507 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
5508 if t.PullRequest != nil {
5509
5510 if len("pullRequest") > 1000000 {
5511 return xerrors.Errorf("Value in field \"pullRequest\" was too long")
5512 }
5513
5514 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullRequest"))); err != nil {
5515 return err
5516 }
5517 if _, err := cw.WriteString(string("pullRequest")); err != nil {
5518 return err
5519 }
5520
5521 if err := t.PullRequest.MarshalCBOR(cw); err != nil {
5522 return err
5523 }
5524 }
5525 return nil
5526}
5527
5528func (t *Pipeline_TriggerMetadata) UnmarshalCBOR(r io.Reader) (err error) {
5529 *t = Pipeline_TriggerMetadata{}
5530
5531 cr := cbg.NewCborReader(r)
5532
5533 maj, extra, err := cr.ReadHeader()
5534 if err != nil {
5535 return err
5536 }
5537 defer func() {
5538 if err == io.EOF {
5539 err = io.ErrUnexpectedEOF
5540 }
5541 }()
5542
5543 if maj != cbg.MajMap {
5544 return fmt.Errorf("cbor input should be of type map")
5545 }
5546
5547 if extra > cbg.MaxLength {
5548 return fmt.Errorf("Pipeline_TriggerMetadata: map struct too large (%d)", extra)
5549 }
5550
5551 n := extra
5552
5553 nameBuf := make([]byte, 11)
5554 for i := uint64(0); i < n; i++ {
5555 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5556 if err != nil {
5557 return err
5558 }
5559
5560 if !ok {
5561 // Field doesn't exist on this type, so ignore it
5562 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5563 return err
5564 }
5565 continue
5566 }
5567
5568 switch string(nameBuf[:nameLen]) {
5569 // t.Kind (string) (string)
5570 case "kind":
5571
5572 {
5573 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5574 if err != nil {
5575 return err
5576 }
5577
5578 t.Kind = string(sval)
5579 }
5580 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
5581 case "push":
5582
5583 {
5584
5585 b, err := cr.ReadByte()
5586 if err != nil {
5587 return err
5588 }
5589 if b != cbg.CborNull[0] {
5590 if err := cr.UnreadByte(); err != nil {
5591 return err
5592 }
5593 t.Push = new(Pipeline_PushTriggerData)
5594 if err := t.Push.UnmarshalCBOR(cr); err != nil {
5595 return xerrors.Errorf("unmarshaling t.Push pointer: %w", err)
5596 }
5597 }
5598
5599 }
5600 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
5601 case "repo":
5602
5603 {
5604
5605 b, err := cr.ReadByte()
5606 if err != nil {
5607 return err
5608 }
5609 if b != cbg.CborNull[0] {
5610 if err := cr.UnreadByte(); err != nil {
5611 return err
5612 }
5613 t.Repo = new(Pipeline_TriggerRepo)
5614 if err := t.Repo.UnmarshalCBOR(cr); err != nil {
5615 return xerrors.Errorf("unmarshaling t.Repo pointer: %w", err)
5616 }
5617 }
5618
5619 }
5620 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
5621 case "manual":
5622
5623 {
5624
5625 b, err := cr.ReadByte()
5626 if err != nil {
5627 return err
5628 }
5629 if b != cbg.CborNull[0] {
5630 if err := cr.UnreadByte(); err != nil {
5631 return err
5632 }
5633 t.Manual = new(Pipeline_ManualTriggerData)
5634 if err := t.Manual.UnmarshalCBOR(cr); err != nil {
5635 return xerrors.Errorf("unmarshaling t.Manual pointer: %w", err)
5636 }
5637 }
5638
5639 }
5640 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
5641 case "pullRequest":
5642
5643 {
5644
5645 b, err := cr.ReadByte()
5646 if err != nil {
5647 return err
5648 }
5649 if b != cbg.CborNull[0] {
5650 if err := cr.UnreadByte(); err != nil {
5651 return err
5652 }
5653 t.PullRequest = new(Pipeline_PullRequestTriggerData)
5654 if err := t.PullRequest.UnmarshalCBOR(cr); err != nil {
5655 return xerrors.Errorf("unmarshaling t.PullRequest pointer: %w", err)
5656 }
5657 }
5658
5659 }
5660
5661 default:
5662 // Field doesn't exist on this type, so ignore it
5663 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5664 return err
5665 }
5666 }
5667 }
5668
5669 return nil
5670}
5671func (t *Pipeline_TriggerRepo) MarshalCBOR(w io.Writer) error {
5672 if t == nil {
5673 _, err := w.Write(cbg.CborNull)
5674 return err
5675 }
5676
5677 cw := cbg.NewCborWriter(w)
5678
5679 if _, err := cw.Write([]byte{164}); err != nil {
5680 return err
5681 }
5682
5683 // t.Did (string) (string)
5684 if len("did") > 1000000 {
5685 return xerrors.Errorf("Value in field \"did\" was too long")
5686 }
5687
5688 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil {
5689 return err
5690 }
5691 if _, err := cw.WriteString(string("did")); err != nil {
5692 return err
5693 }
5694
5695 if len(t.Did) > 1000000 {
5696 return xerrors.Errorf("Value in field t.Did was too long")
5697 }
5698
5699 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil {
5700 return err
5701 }
5702 if _, err := cw.WriteString(string(t.Did)); err != nil {
5703 return err
5704 }
5705
5706 // t.Knot (string) (string)
5707 if len("knot") > 1000000 {
5708 return xerrors.Errorf("Value in field \"knot\" was too long")
5709 }
5710
5711 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
5712 return err
5713 }
5714 if _, err := cw.WriteString(string("knot")); err != nil {
5715 return err
5716 }
5717
5718 if len(t.Knot) > 1000000 {
5719 return xerrors.Errorf("Value in field t.Knot was too long")
5720 }
5721
5722 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
5723 return err
5724 }
5725 if _, err := cw.WriteString(string(t.Knot)); err != nil {
5726 return err
5727 }
5728
5729 // t.Repo (string) (string)
5730 if len("repo") > 1000000 {
5731 return xerrors.Errorf("Value in field \"repo\" was too long")
5732 }
5733
5734 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5735 return err
5736 }
5737 if _, err := cw.WriteString(string("repo")); err != nil {
5738 return err
5739 }
5740
5741 if len(t.Repo) > 1000000 {
5742 return xerrors.Errorf("Value in field t.Repo was too long")
5743 }
5744
5745 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
5746 return err
5747 }
5748 if _, err := cw.WriteString(string(t.Repo)); err != nil {
5749 return err
5750 }
5751
5752 // t.DefaultBranch (string) (string)
5753 if len("defaultBranch") > 1000000 {
5754 return xerrors.Errorf("Value in field \"defaultBranch\" was too long")
5755 }
5756
5757 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("defaultBranch"))); err != nil {
5758 return err
5759 }
5760 if _, err := cw.WriteString(string("defaultBranch")); err != nil {
5761 return err
5762 }
5763
5764 if len(t.DefaultBranch) > 1000000 {
5765 return xerrors.Errorf("Value in field t.DefaultBranch was too long")
5766 }
5767
5768 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.DefaultBranch))); err != nil {
5769 return err
5770 }
5771 if _, err := cw.WriteString(string(t.DefaultBranch)); err != nil {
5772 return err
5773 }
5774 return nil
5775}
5776
5777func (t *Pipeline_TriggerRepo) UnmarshalCBOR(r io.Reader) (err error) {
5778 *t = Pipeline_TriggerRepo{}
5779
5780 cr := cbg.NewCborReader(r)
5781
5782 maj, extra, err := cr.ReadHeader()
5783 if err != nil {
5784 return err
5785 }
5786 defer func() {
5787 if err == io.EOF {
5788 err = io.ErrUnexpectedEOF
5789 }
5790 }()
5791
5792 if maj != cbg.MajMap {
5793 return fmt.Errorf("cbor input should be of type map")
5794 }
5795
5796 if extra > cbg.MaxLength {
5797 return fmt.Errorf("Pipeline_TriggerRepo: map struct too large (%d)", extra)
5798 }
5799
5800 n := extra
5801
5802 nameBuf := make([]byte, 13)
5803 for i := uint64(0); i < n; i++ {
5804 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5805 if err != nil {
5806 return err
5807 }
5808
5809 if !ok {
5810 // Field doesn't exist on this type, so ignore it
5811 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5812 return err
5813 }
5814 continue
5815 }
5816
5817 switch string(nameBuf[:nameLen]) {
5818 // t.Did (string) (string)
5819 case "did":
5820
5821 {
5822 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5823 if err != nil {
5824 return err
5825 }
5826
5827 t.Did = string(sval)
5828 }
5829 // t.Knot (string) (string)
5830 case "knot":
5831
5832 {
5833 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5834 if err != nil {
5835 return err
5836 }
5837
5838 t.Knot = string(sval)
5839 }
5840 // t.Repo (string) (string)
5841 case "repo":
5842
5843 {
5844 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5845 if err != nil {
5846 return err
5847 }
5848
5849 t.Repo = string(sval)
5850 }
5851 // t.DefaultBranch (string) (string)
5852 case "defaultBranch":
5853
5854 {
5855 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5856 if err != nil {
5857 return err
5858 }
5859
5860 t.DefaultBranch = string(sval)
5861 }
5862
5863 default:
5864 // Field doesn't exist on this type, so ignore it
5865 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5866 return err
5867 }
5868 }
5869 }
5870
5871 return nil
5872}
5873func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error {
5874 if t == nil {
5875 _, err := w.Write(cbg.CborNull)
5876 return err
5877 }
5878
5879 cw := cbg.NewCborWriter(w)
5880
5881 if _, err := cw.Write([]byte{164}); err != nil {
5882 return err
5883 }
5884
5885 // t.Raw (string) (string)
5886 if len("raw") > 1000000 {
5887 return xerrors.Errorf("Value in field \"raw\" was too long")
5888 }
5889
5890 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("raw"))); err != nil {
5891 return err
5892 }
5893 if _, err := cw.WriteString(string("raw")); err != nil {
5894 return err
5895 }
5896
5897 if len(t.Raw) > 1000000 {
5898 return xerrors.Errorf("Value in field t.Raw was too long")
5899 }
5900
5901 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Raw))); err != nil {
5902 return err
5903 }
5904 if _, err := cw.WriteString(string(t.Raw)); err != nil {
5905 return err
5906 }
5907
5908 // t.Name (string) (string)
5909 if len("name") > 1000000 {
5910 return xerrors.Errorf("Value in field \"name\" was too long")
5911 }
5912
5913 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5914 return err
5915 }
5916 if _, err := cw.WriteString(string("name")); err != nil {
5917 return err
5918 }
5919
5920 if len(t.Name) > 1000000 {
5921 return xerrors.Errorf("Value in field t.Name was too long")
5922 }
5923
5924 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5925 return err
5926 }
5927 if _, err := cw.WriteString(string(t.Name)); err != nil {
5928 return err
5929 }
5930
5931 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
5932 if len("clone") > 1000000 {
5933 return xerrors.Errorf("Value in field \"clone\" was too long")
5934 }
5935
5936 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil {
5937 return err
5938 }
5939 if _, err := cw.WriteString(string("clone")); err != nil {
5940 return err
5941 }
5942
5943 if err := t.Clone.MarshalCBOR(cw); err != nil {
5944 return err
5945 }
5946
5947 // t.Engine (string) (string)
5948 if len("engine") > 1000000 {
5949 return xerrors.Errorf("Value in field \"engine\" was too long")
5950 }
5951
5952 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("engine"))); err != nil {
5953 return err
5954 }
5955 if _, err := cw.WriteString(string("engine")); err != nil {
5956 return err
5957 }
5958
5959 if len(t.Engine) > 1000000 {
5960 return xerrors.Errorf("Value in field t.Engine was too long")
5961 }
5962
5963 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Engine))); err != nil {
5964 return err
5965 }
5966 if _, err := cw.WriteString(string(t.Engine)); err != nil {
5967 return err
5968 }
5969 return nil
5970}
5971
5972func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) {
5973 *t = Pipeline_Workflow{}
5974
5975 cr := cbg.NewCborReader(r)
5976
5977 maj, extra, err := cr.ReadHeader()
5978 if err != nil {
5979 return err
5980 }
5981 defer func() {
5982 if err == io.EOF {
5983 err = io.ErrUnexpectedEOF
5984 }
5985 }()
5986
5987 if maj != cbg.MajMap {
5988 return fmt.Errorf("cbor input should be of type map")
5989 }
5990
5991 if extra > cbg.MaxLength {
5992 return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra)
5993 }
5994
5995 n := extra
5996
5997 nameBuf := make([]byte, 6)
5998 for i := uint64(0); i < n; i++ {
5999 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6000 if err != nil {
6001 return err
6002 }
6003
6004 if !ok {
6005 // Field doesn't exist on this type, so ignore it
6006 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6007 return err
6008 }
6009 continue
6010 }
6011
6012 switch string(nameBuf[:nameLen]) {
6013 // t.Raw (string) (string)
6014 case "raw":
6015
6016 {
6017 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6018 if err != nil {
6019 return err
6020 }
6021
6022 t.Raw = string(sval)
6023 }
6024 // t.Name (string) (string)
6025 case "name":
6026
6027 {
6028 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6029 if err != nil {
6030 return err
6031 }
6032
6033 t.Name = string(sval)
6034 }
6035 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
6036 case "clone":
6037
6038 {
6039
6040 b, err := cr.ReadByte()
6041 if err != nil {
6042 return err
6043 }
6044 if b != cbg.CborNull[0] {
6045 if err := cr.UnreadByte(); err != nil {
6046 return err
6047 }
6048 t.Clone = new(Pipeline_CloneOpts)
6049 if err := t.Clone.UnmarshalCBOR(cr); err != nil {
6050 return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err)
6051 }
6052 }
6053
6054 }
6055 // t.Engine (string) (string)
6056 case "engine":
6057
6058 {
6059 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6060 if err != nil {
6061 return err
6062 }
6063
6064 t.Engine = string(sval)
6065 }
6066
6067 default:
6068 // Field doesn't exist on this type, so ignore it
6069 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6070 return err
6071 }
6072 }
6073 }
6074
6075 return nil
6076}
6077func (t *PublicKey) MarshalCBOR(w io.Writer) error {
6078 if t == nil {
6079 _, err := w.Write(cbg.CborNull)
6080 return err
6081 }
6082
6083 cw := cbg.NewCborWriter(w)
6084
6085 if _, err := cw.Write([]byte{164}); err != nil {
6086 return err
6087 }
6088
6089 // t.Key (string) (string)
6090 if len("key") > 1000000 {
6091 return xerrors.Errorf("Value in field \"key\" was too long")
6092 }
6093
6094 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
6095 return err
6096 }
6097 if _, err := cw.WriteString(string("key")); err != nil {
6098 return err
6099 }
6100
6101 if len(t.Key) > 1000000 {
6102 return xerrors.Errorf("Value in field t.Key was too long")
6103 }
6104
6105 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
6106 return err
6107 }
6108 if _, err := cw.WriteString(string(t.Key)); err != nil {
6109 return err
6110 }
6111
6112 // t.Name (string) (string)
6113 if len("name") > 1000000 {
6114 return xerrors.Errorf("Value in field \"name\" was too long")
6115 }
6116
6117 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
6118 return err
6119 }
6120 if _, err := cw.WriteString(string("name")); err != nil {
6121 return err
6122 }
6123
6124 if len(t.Name) > 1000000 {
6125 return xerrors.Errorf("Value in field t.Name was too long")
6126 }
6127
6128 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
6129 return err
6130 }
6131 if _, err := cw.WriteString(string(t.Name)); err != nil {
6132 return err
6133 }
6134
6135 // t.LexiconTypeID (string) (string)
6136 if len("$type") > 1000000 {
6137 return xerrors.Errorf("Value in field \"$type\" was too long")
6138 }
6139
6140 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6141 return err
6142 }
6143 if _, err := cw.WriteString(string("$type")); err != nil {
6144 return err
6145 }
6146
6147 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil {
6148 return err
6149 }
6150 if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil {
6151 return err
6152 }
6153
6154 // t.CreatedAt (string) (string)
6155 if len("createdAt") > 1000000 {
6156 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6157 }
6158
6159 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6160 return err
6161 }
6162 if _, err := cw.WriteString(string("createdAt")); err != nil {
6163 return err
6164 }
6165
6166 if len(t.CreatedAt) > 1000000 {
6167 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6168 }
6169
6170 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6171 return err
6172 }
6173 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6174 return err
6175 }
6176 return nil
6177}
6178
6179func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) {
6180 *t = PublicKey{}
6181
6182 cr := cbg.NewCborReader(r)
6183
6184 maj, extra, err := cr.ReadHeader()
6185 if err != nil {
6186 return err
6187 }
6188 defer func() {
6189 if err == io.EOF {
6190 err = io.ErrUnexpectedEOF
6191 }
6192 }()
6193
6194 if maj != cbg.MajMap {
6195 return fmt.Errorf("cbor input should be of type map")
6196 }
6197
6198 if extra > cbg.MaxLength {
6199 return fmt.Errorf("PublicKey: map struct too large (%d)", extra)
6200 }
6201
6202 n := extra
6203
6204 nameBuf := make([]byte, 9)
6205 for i := uint64(0); i < n; i++ {
6206 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6207 if err != nil {
6208 return err
6209 }
6210
6211 if !ok {
6212 // Field doesn't exist on this type, so ignore it
6213 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6214 return err
6215 }
6216 continue
6217 }
6218
6219 switch string(nameBuf[:nameLen]) {
6220 // t.Key (string) (string)
6221 case "key":
6222
6223 {
6224 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6225 if err != nil {
6226 return err
6227 }
6228
6229 t.Key = string(sval)
6230 }
6231 // t.Name (string) (string)
6232 case "name":
6233
6234 {
6235 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6236 if err != nil {
6237 return err
6238 }
6239
6240 t.Name = string(sval)
6241 }
6242 // t.LexiconTypeID (string) (string)
6243 case "$type":
6244
6245 {
6246 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6247 if err != nil {
6248 return err
6249 }
6250
6251 t.LexiconTypeID = string(sval)
6252 }
6253 // t.CreatedAt (string) (string)
6254 case "createdAt":
6255
6256 {
6257 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6258 if err != nil {
6259 return err
6260 }
6261
6262 t.CreatedAt = string(sval)
6263 }
6264
6265 default:
6266 // Field doesn't exist on this type, so ignore it
6267 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6268 return err
6269 }
6270 }
6271 }
6272
6273 return nil
6274}
6275func (t *Repo) MarshalCBOR(w io.Writer) error {
6276 if t == nil {
6277 _, err := w.Write(cbg.CborNull)
6278 return err
6279 }
6280
6281 cw := cbg.NewCborWriter(w)
6282 fieldCount := 10
6283
6284 if t.Description == nil {
6285 fieldCount--
6286 }
6287
6288 if t.Labels == nil {
6289 fieldCount--
6290 }
6291
6292 if t.Source == nil {
6293 fieldCount--
6294 }
6295
6296 if t.Spindle == nil {
6297 fieldCount--
6298 }
6299
6300 if t.Topics == nil {
6301 fieldCount--
6302 }
6303
6304 if t.Website == nil {
6305 fieldCount--
6306 }
6307
6308 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6309 return err
6310 }
6311
6312 // t.Knot (string) (string)
6313 if len("knot") > 1000000 {
6314 return xerrors.Errorf("Value in field \"knot\" was too long")
6315 }
6316
6317 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
6318 return err
6319 }
6320 if _, err := cw.WriteString(string("knot")); err != nil {
6321 return err
6322 }
6323
6324 if len(t.Knot) > 1000000 {
6325 return xerrors.Errorf("Value in field t.Knot was too long")
6326 }
6327
6328 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
6329 return err
6330 }
6331 if _, err := cw.WriteString(string(t.Knot)); err != nil {
6332 return err
6333 }
6334
6335 // t.Name (string) (string)
6336 if len("name") > 1000000 {
6337 return xerrors.Errorf("Value in field \"name\" was too long")
6338 }
6339
6340 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
6341 return err
6342 }
6343 if _, err := cw.WriteString(string("name")); err != nil {
6344 return err
6345 }
6346
6347 if len(t.Name) > 1000000 {
6348 return xerrors.Errorf("Value in field t.Name was too long")
6349 }
6350
6351 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
6352 return err
6353 }
6354 if _, err := cw.WriteString(string(t.Name)); err != nil {
6355 return err
6356 }
6357
6358 // t.LexiconTypeID (string) (string)
6359 if len("$type") > 1000000 {
6360 return xerrors.Errorf("Value in field \"$type\" was too long")
6361 }
6362
6363 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6364 return err
6365 }
6366 if _, err := cw.WriteString(string("$type")); err != nil {
6367 return err
6368 }
6369
6370 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil {
6371 return err
6372 }
6373 if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil {
6374 return err
6375 }
6376
6377 // t.Labels ([]string) (slice)
6378 if t.Labels != nil {
6379
6380 if len("labels") > 1000000 {
6381 return xerrors.Errorf("Value in field \"labels\" was too long")
6382 }
6383
6384 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("labels"))); err != nil {
6385 return err
6386 }
6387 if _, err := cw.WriteString(string("labels")); err != nil {
6388 return err
6389 }
6390
6391 if len(t.Labels) > 8192 {
6392 return xerrors.Errorf("Slice value in field t.Labels was too long")
6393 }
6394
6395 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Labels))); err != nil {
6396 return err
6397 }
6398 for _, v := range t.Labels {
6399 if len(v) > 1000000 {
6400 return xerrors.Errorf("Value in field v was too long")
6401 }
6402
6403 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
6404 return err
6405 }
6406 if _, err := cw.WriteString(string(v)); err != nil {
6407 return err
6408 }
6409
6410 }
6411 }
6412
6413 // t.Source (string) (string)
6414 if t.Source != nil {
6415
6416 if len("source") > 1000000 {
6417 return xerrors.Errorf("Value in field \"source\" was too long")
6418 }
6419
6420 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
6421 return err
6422 }
6423 if _, err := cw.WriteString(string("source")); err != nil {
6424 return err
6425 }
6426
6427 if t.Source == nil {
6428 if _, err := cw.Write(cbg.CborNull); err != nil {
6429 return err
6430 }
6431 } else {
6432 if len(*t.Source) > 1000000 {
6433 return xerrors.Errorf("Value in field t.Source was too long")
6434 }
6435
6436 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil {
6437 return err
6438 }
6439 if _, err := cw.WriteString(string(*t.Source)); err != nil {
6440 return err
6441 }
6442 }
6443 }
6444
6445 // t.Topics ([]string) (slice)
6446 if t.Topics != nil {
6447
6448 if len("topics") > 1000000 {
6449 return xerrors.Errorf("Value in field \"topics\" was too long")
6450 }
6451
6452 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("topics"))); err != nil {
6453 return err
6454 }
6455 if _, err := cw.WriteString(string("topics")); err != nil {
6456 return err
6457 }
6458
6459 if len(t.Topics) > 8192 {
6460 return xerrors.Errorf("Slice value in field t.Topics was too long")
6461 }
6462
6463 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Topics))); err != nil {
6464 return err
6465 }
6466 for _, v := range t.Topics {
6467 if len(v) > 1000000 {
6468 return xerrors.Errorf("Value in field v was too long")
6469 }
6470
6471 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
6472 return err
6473 }
6474 if _, err := cw.WriteString(string(v)); err != nil {
6475 return err
6476 }
6477
6478 }
6479 }
6480
6481 // t.Spindle (string) (string)
6482 if t.Spindle != nil {
6483
6484 if len("spindle") > 1000000 {
6485 return xerrors.Errorf("Value in field \"spindle\" was too long")
6486 }
6487
6488 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("spindle"))); err != nil {
6489 return err
6490 }
6491 if _, err := cw.WriteString(string("spindle")); err != nil {
6492 return err
6493 }
6494
6495 if t.Spindle == nil {
6496 if _, err := cw.Write(cbg.CborNull); err != nil {
6497 return err
6498 }
6499 } else {
6500 if len(*t.Spindle) > 1000000 {
6501 return xerrors.Errorf("Value in field t.Spindle was too long")
6502 }
6503
6504 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Spindle))); err != nil {
6505 return err
6506 }
6507 if _, err := cw.WriteString(string(*t.Spindle)); err != nil {
6508 return err
6509 }
6510 }
6511 }
6512
6513 // t.Website (string) (string)
6514 if t.Website != nil {
6515
6516 if len("website") > 1000000 {
6517 return xerrors.Errorf("Value in field \"website\" was too long")
6518 }
6519
6520 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("website"))); err != nil {
6521 return err
6522 }
6523 if _, err := cw.WriteString(string("website")); err != nil {
6524 return err
6525 }
6526
6527 if t.Website == nil {
6528 if _, err := cw.Write(cbg.CborNull); err != nil {
6529 return err
6530 }
6531 } else {
6532 if len(*t.Website) > 1000000 {
6533 return xerrors.Errorf("Value in field t.Website was too long")
6534 }
6535
6536 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Website))); err != nil {
6537 return err
6538 }
6539 if _, err := cw.WriteString(string(*t.Website)); err != nil {
6540 return err
6541 }
6542 }
6543 }
6544
6545 // t.CreatedAt (string) (string)
6546 if len("createdAt") > 1000000 {
6547 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6548 }
6549
6550 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6551 return err
6552 }
6553 if _, err := cw.WriteString(string("createdAt")); err != nil {
6554 return err
6555 }
6556
6557 if len(t.CreatedAt) > 1000000 {
6558 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6559 }
6560
6561 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6562 return err
6563 }
6564 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6565 return err
6566 }
6567
6568 // t.Description (string) (string)
6569 if t.Description != nil {
6570
6571 if len("description") > 1000000 {
6572 return xerrors.Errorf("Value in field \"description\" was too long")
6573 }
6574
6575 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
6576 return err
6577 }
6578 if _, err := cw.WriteString(string("description")); err != nil {
6579 return err
6580 }
6581
6582 if t.Description == nil {
6583 if _, err := cw.Write(cbg.CborNull); err != nil {
6584 return err
6585 }
6586 } else {
6587 if len(*t.Description) > 1000000 {
6588 return xerrors.Errorf("Value in field t.Description was too long")
6589 }
6590
6591 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
6592 return err
6593 }
6594 if _, err := cw.WriteString(string(*t.Description)); err != nil {
6595 return err
6596 }
6597 }
6598 }
6599 return nil
6600}
6601
6602func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) {
6603 *t = Repo{}
6604
6605 cr := cbg.NewCborReader(r)
6606
6607 maj, extra, err := cr.ReadHeader()
6608 if err != nil {
6609 return err
6610 }
6611 defer func() {
6612 if err == io.EOF {
6613 err = io.ErrUnexpectedEOF
6614 }
6615 }()
6616
6617 if maj != cbg.MajMap {
6618 return fmt.Errorf("cbor input should be of type map")
6619 }
6620
6621 if extra > cbg.MaxLength {
6622 return fmt.Errorf("Repo: map struct too large (%d)", extra)
6623 }
6624
6625 n := extra
6626
6627 nameBuf := make([]byte, 11)
6628 for i := uint64(0); i < n; i++ {
6629 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6630 if err != nil {
6631 return err
6632 }
6633
6634 if !ok {
6635 // Field doesn't exist on this type, so ignore it
6636 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6637 return err
6638 }
6639 continue
6640 }
6641
6642 switch string(nameBuf[:nameLen]) {
6643 // t.Knot (string) (string)
6644 case "knot":
6645
6646 {
6647 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6648 if err != nil {
6649 return err
6650 }
6651
6652 t.Knot = string(sval)
6653 }
6654 // t.Name (string) (string)
6655 case "name":
6656
6657 {
6658 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6659 if err != nil {
6660 return err
6661 }
6662
6663 t.Name = string(sval)
6664 }
6665 // t.LexiconTypeID (string) (string)
6666 case "$type":
6667
6668 {
6669 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6670 if err != nil {
6671 return err
6672 }
6673
6674 t.LexiconTypeID = string(sval)
6675 }
6676 // t.Labels ([]string) (slice)
6677 case "labels":
6678
6679 maj, extra, err = cr.ReadHeader()
6680 if err != nil {
6681 return err
6682 }
6683
6684 if extra > 8192 {
6685 return fmt.Errorf("t.Labels: array too large (%d)", extra)
6686 }
6687
6688 if maj != cbg.MajArray {
6689 return fmt.Errorf("expected cbor array")
6690 }
6691
6692 if extra > 0 {
6693 t.Labels = make([]string, extra)
6694 }
6695
6696 for i := 0; i < int(extra); i++ {
6697 {
6698 var maj byte
6699 var extra uint64
6700 var err error
6701 _ = maj
6702 _ = extra
6703 _ = err
6704
6705 {
6706 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6707 if err != nil {
6708 return err
6709 }
6710
6711 t.Labels[i] = string(sval)
6712 }
6713
6714 }
6715 }
6716 // t.Source (string) (string)
6717 case "source":
6718
6719 {
6720 b, err := cr.ReadByte()
6721 if err != nil {
6722 return err
6723 }
6724 if b != cbg.CborNull[0] {
6725 if err := cr.UnreadByte(); err != nil {
6726 return err
6727 }
6728
6729 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6730 if err != nil {
6731 return err
6732 }
6733
6734 t.Source = (*string)(&sval)
6735 }
6736 }
6737 // t.Topics ([]string) (slice)
6738 case "topics":
6739
6740 maj, extra, err = cr.ReadHeader()
6741 if err != nil {
6742 return err
6743 }
6744
6745 if extra > 8192 {
6746 return fmt.Errorf("t.Topics: array too large (%d)", extra)
6747 }
6748
6749 if maj != cbg.MajArray {
6750 return fmt.Errorf("expected cbor array")
6751 }
6752
6753 if extra > 0 {
6754 t.Topics = make([]string, extra)
6755 }
6756
6757 for i := 0; i < int(extra); i++ {
6758 {
6759 var maj byte
6760 var extra uint64
6761 var err error
6762 _ = maj
6763 _ = extra
6764 _ = err
6765
6766 {
6767 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6768 if err != nil {
6769 return err
6770 }
6771
6772 t.Topics[i] = string(sval)
6773 }
6774
6775 }
6776 }
6777 // t.Spindle (string) (string)
6778 case "spindle":
6779
6780 {
6781 b, err := cr.ReadByte()
6782 if err != nil {
6783 return err
6784 }
6785 if b != cbg.CborNull[0] {
6786 if err := cr.UnreadByte(); err != nil {
6787 return err
6788 }
6789
6790 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6791 if err != nil {
6792 return err
6793 }
6794
6795 t.Spindle = (*string)(&sval)
6796 }
6797 }
6798 // t.Website (string) (string)
6799 case "website":
6800
6801 {
6802 b, err := cr.ReadByte()
6803 if err != nil {
6804 return err
6805 }
6806 if b != cbg.CborNull[0] {
6807 if err := cr.UnreadByte(); err != nil {
6808 return err
6809 }
6810
6811 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6812 if err != nil {
6813 return err
6814 }
6815
6816 t.Website = (*string)(&sval)
6817 }
6818 }
6819 // t.CreatedAt (string) (string)
6820 case "createdAt":
6821
6822 {
6823 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6824 if err != nil {
6825 return err
6826 }
6827
6828 t.CreatedAt = string(sval)
6829 }
6830 // t.Description (string) (string)
6831 case "description":
6832
6833 {
6834 b, err := cr.ReadByte()
6835 if err != nil {
6836 return err
6837 }
6838 if b != cbg.CborNull[0] {
6839 if err := cr.UnreadByte(); err != nil {
6840 return err
6841 }
6842
6843 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6844 if err != nil {
6845 return err
6846 }
6847
6848 t.Description = (*string)(&sval)
6849 }
6850 }
6851
6852 default:
6853 // Field doesn't exist on this type, so ignore it
6854 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6855 return err
6856 }
6857 }
6858 }
6859
6860 return nil
6861}
6862func (t *RepoArtifact) MarshalCBOR(w io.Writer) error {
6863 if t == nil {
6864 _, err := w.Write(cbg.CborNull)
6865 return err
6866 }
6867
6868 cw := cbg.NewCborWriter(w)
6869 fieldCount := 6
6870
6871 if t.Tag == nil {
6872 fieldCount--
6873 }
6874
6875 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6876 return err
6877 }
6878
6879 // t.Tag (util.LexBytes) (slice)
6880 if t.Tag != nil {
6881
6882 if len("tag") > 1000000 {
6883 return xerrors.Errorf("Value in field \"tag\" was too long")
6884 }
6885
6886 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tag"))); err != nil {
6887 return err
6888 }
6889 if _, err := cw.WriteString(string("tag")); err != nil {
6890 return err
6891 }
6892
6893 if len(t.Tag) > 2097152 {
6894 return xerrors.Errorf("Byte array in field t.Tag was too long")
6895 }
6896
6897 if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Tag))); err != nil {
6898 return err
6899 }
6900
6901 if _, err := cw.Write(t.Tag); err != nil {
6902 return err
6903 }
6904
6905 }
6906
6907 // t.Name (string) (string)
6908 if len("name") > 1000000 {
6909 return xerrors.Errorf("Value in field \"name\" was too long")
6910 }
6911
6912 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
6913 return err
6914 }
6915 if _, err := cw.WriteString(string("name")); err != nil {
6916 return err
6917 }
6918
6919 if len(t.Name) > 1000000 {
6920 return xerrors.Errorf("Value in field t.Name was too long")
6921 }
6922
6923 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
6924 return err
6925 }
6926 if _, err := cw.WriteString(string(t.Name)); err != nil {
6927 return err
6928 }
6929
6930 // t.Repo (string) (string)
6931 if len("repo") > 1000000 {
6932 return xerrors.Errorf("Value in field \"repo\" was too long")
6933 }
6934
6935 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6936 return err
6937 }
6938 if _, err := cw.WriteString(string("repo")); err != nil {
6939 return err
6940 }
6941
6942 if len(t.Repo) > 1000000 {
6943 return xerrors.Errorf("Value in field t.Repo was too long")
6944 }
6945
6946 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
6947 return err
6948 }
6949 if _, err := cw.WriteString(string(t.Repo)); err != nil {
6950 return err
6951 }
6952
6953 // t.LexiconTypeID (string) (string)
6954 if len("$type") > 1000000 {
6955 return xerrors.Errorf("Value in field \"$type\" was too long")
6956 }
6957
6958 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6959 return err
6960 }
6961 if _, err := cw.WriteString(string("$type")); err != nil {
6962 return err
6963 }
6964
6965 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.artifact"))); err != nil {
6966 return err
6967 }
6968 if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil {
6969 return err
6970 }
6971
6972 // t.Artifact (util.LexBlob) (struct)
6973 if len("artifact") > 1000000 {
6974 return xerrors.Errorf("Value in field \"artifact\" was too long")
6975 }
6976
6977 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("artifact"))); err != nil {
6978 return err
6979 }
6980 if _, err := cw.WriteString(string("artifact")); err != nil {
6981 return err
6982 }
6983
6984 if err := t.Artifact.MarshalCBOR(cw); err != nil {
6985 return err
6986 }
6987
6988 // t.CreatedAt (string) (string)
6989 if len("createdAt") > 1000000 {
6990 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6991 }
6992
6993 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6994 return err
6995 }
6996 if _, err := cw.WriteString(string("createdAt")); err != nil {
6997 return err
6998 }
6999
7000 if len(t.CreatedAt) > 1000000 {
7001 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7002 }
7003
7004 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7005 return err
7006 }
7007 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7008 return err
7009 }
7010 return nil
7011}
7012
7013func (t *RepoArtifact) UnmarshalCBOR(r io.Reader) (err error) {
7014 *t = RepoArtifact{}
7015
7016 cr := cbg.NewCborReader(r)
7017
7018 maj, extra, err := cr.ReadHeader()
7019 if err != nil {
7020 return err
7021 }
7022 defer func() {
7023 if err == io.EOF {
7024 err = io.ErrUnexpectedEOF
7025 }
7026 }()
7027
7028 if maj != cbg.MajMap {
7029 return fmt.Errorf("cbor input should be of type map")
7030 }
7031
7032 if extra > cbg.MaxLength {
7033 return fmt.Errorf("RepoArtifact: map struct too large (%d)", extra)
7034 }
7035
7036 n := extra
7037
7038 nameBuf := make([]byte, 9)
7039 for i := uint64(0); i < n; i++ {
7040 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7041 if err != nil {
7042 return err
7043 }
7044
7045 if !ok {
7046 // Field doesn't exist on this type, so ignore it
7047 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7048 return err
7049 }
7050 continue
7051 }
7052
7053 switch string(nameBuf[:nameLen]) {
7054 // t.Tag (util.LexBytes) (slice)
7055 case "tag":
7056
7057 maj, extra, err = cr.ReadHeader()
7058 if err != nil {
7059 return err
7060 }
7061
7062 if extra > 2097152 {
7063 return fmt.Errorf("t.Tag: byte array too large (%d)", extra)
7064 }
7065 if maj != cbg.MajByteString {
7066 return fmt.Errorf("expected byte array")
7067 }
7068
7069 if extra > 0 {
7070 t.Tag = make([]uint8, extra)
7071 }
7072
7073 if _, err := io.ReadFull(cr, t.Tag); err != nil {
7074 return err
7075 }
7076
7077 // t.Name (string) (string)
7078 case "name":
7079
7080 {
7081 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7082 if err != nil {
7083 return err
7084 }
7085
7086 t.Name = string(sval)
7087 }
7088 // t.Repo (string) (string)
7089 case "repo":
7090
7091 {
7092 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7093 if err != nil {
7094 return err
7095 }
7096
7097 t.Repo = string(sval)
7098 }
7099 // t.LexiconTypeID (string) (string)
7100 case "$type":
7101
7102 {
7103 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7104 if err != nil {
7105 return err
7106 }
7107
7108 t.LexiconTypeID = string(sval)
7109 }
7110 // t.Artifact (util.LexBlob) (struct)
7111 case "artifact":
7112
7113 {
7114
7115 b, err := cr.ReadByte()
7116 if err != nil {
7117 return err
7118 }
7119 if b != cbg.CborNull[0] {
7120 if err := cr.UnreadByte(); err != nil {
7121 return err
7122 }
7123 t.Artifact = new(util.LexBlob)
7124 if err := t.Artifact.UnmarshalCBOR(cr); err != nil {
7125 return xerrors.Errorf("unmarshaling t.Artifact pointer: %w", err)
7126 }
7127 }
7128
7129 }
7130 // t.CreatedAt (string) (string)
7131 case "createdAt":
7132
7133 {
7134 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7135 if err != nil {
7136 return err
7137 }
7138
7139 t.CreatedAt = string(sval)
7140 }
7141
7142 default:
7143 // Field doesn't exist on this type, so ignore it
7144 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7145 return err
7146 }
7147 }
7148 }
7149
7150 return nil
7151}
7152func (t *RepoCollaborator) MarshalCBOR(w io.Writer) error {
7153 if t == nil {
7154 _, err := w.Write(cbg.CborNull)
7155 return err
7156 }
7157
7158 cw := cbg.NewCborWriter(w)
7159
7160 if _, err := cw.Write([]byte{164}); err != nil {
7161 return err
7162 }
7163
7164 // t.Repo (string) (string)
7165 if len("repo") > 1000000 {
7166 return xerrors.Errorf("Value in field \"repo\" was too long")
7167 }
7168
7169 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
7170 return err
7171 }
7172 if _, err := cw.WriteString(string("repo")); err != nil {
7173 return err
7174 }
7175
7176 if len(t.Repo) > 1000000 {
7177 return xerrors.Errorf("Value in field t.Repo was too long")
7178 }
7179
7180 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
7181 return err
7182 }
7183 if _, err := cw.WriteString(string(t.Repo)); err != nil {
7184 return err
7185 }
7186
7187 // t.LexiconTypeID (string) (string)
7188 if len("$type") > 1000000 {
7189 return xerrors.Errorf("Value in field \"$type\" was too long")
7190 }
7191
7192 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7193 return err
7194 }
7195 if _, err := cw.WriteString(string("$type")); err != nil {
7196 return err
7197 }
7198
7199 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.collaborator"))); err != nil {
7200 return err
7201 }
7202 if _, err := cw.WriteString(string("sh.tangled.repo.collaborator")); err != nil {
7203 return err
7204 }
7205
7206 // t.Subject (string) (string)
7207 if len("subject") > 1000000 {
7208 return xerrors.Errorf("Value in field \"subject\" was too long")
7209 }
7210
7211 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
7212 return err
7213 }
7214 if _, err := cw.WriteString(string("subject")); err != nil {
7215 return err
7216 }
7217
7218 if len(t.Subject) > 1000000 {
7219 return xerrors.Errorf("Value in field t.Subject was too long")
7220 }
7221
7222 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
7223 return err
7224 }
7225 if _, err := cw.WriteString(string(t.Subject)); err != nil {
7226 return err
7227 }
7228
7229 // t.CreatedAt (string) (string)
7230 if len("createdAt") > 1000000 {
7231 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7232 }
7233
7234 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7235 return err
7236 }
7237 if _, err := cw.WriteString(string("createdAt")); err != nil {
7238 return err
7239 }
7240
7241 if len(t.CreatedAt) > 1000000 {
7242 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7243 }
7244
7245 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7246 return err
7247 }
7248 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7249 return err
7250 }
7251 return nil
7252}
7253
7254func (t *RepoCollaborator) UnmarshalCBOR(r io.Reader) (err error) {
7255 *t = RepoCollaborator{}
7256
7257 cr := cbg.NewCborReader(r)
7258
7259 maj, extra, err := cr.ReadHeader()
7260 if err != nil {
7261 return err
7262 }
7263 defer func() {
7264 if err == io.EOF {
7265 err = io.ErrUnexpectedEOF
7266 }
7267 }()
7268
7269 if maj != cbg.MajMap {
7270 return fmt.Errorf("cbor input should be of type map")
7271 }
7272
7273 if extra > cbg.MaxLength {
7274 return fmt.Errorf("RepoCollaborator: map struct too large (%d)", extra)
7275 }
7276
7277 n := extra
7278
7279 nameBuf := make([]byte, 9)
7280 for i := uint64(0); i < n; i++ {
7281 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7282 if err != nil {
7283 return err
7284 }
7285
7286 if !ok {
7287 // Field doesn't exist on this type, so ignore it
7288 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7289 return err
7290 }
7291 continue
7292 }
7293
7294 switch string(nameBuf[:nameLen]) {
7295 // t.Repo (string) (string)
7296 case "repo":
7297
7298 {
7299 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7300 if err != nil {
7301 return err
7302 }
7303
7304 t.Repo = string(sval)
7305 }
7306 // t.LexiconTypeID (string) (string)
7307 case "$type":
7308
7309 {
7310 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7311 if err != nil {
7312 return err
7313 }
7314
7315 t.LexiconTypeID = string(sval)
7316 }
7317 // t.Subject (string) (string)
7318 case "subject":
7319
7320 {
7321 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7322 if err != nil {
7323 return err
7324 }
7325
7326 t.Subject = string(sval)
7327 }
7328 // t.CreatedAt (string) (string)
7329 case "createdAt":
7330
7331 {
7332 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7333 if err != nil {
7334 return err
7335 }
7336
7337 t.CreatedAt = string(sval)
7338 }
7339
7340 default:
7341 // Field doesn't exist on this type, so ignore it
7342 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7343 return err
7344 }
7345 }
7346 }
7347
7348 return nil
7349}
7350func (t *RepoIssue) MarshalCBOR(w io.Writer) error {
7351 if t == nil {
7352 _, err := w.Write(cbg.CborNull)
7353 return err
7354 }
7355
7356 cw := cbg.NewCborWriter(w)
7357 fieldCount := 7
7358
7359 if t.Body == nil {
7360 fieldCount--
7361 }
7362
7363 if t.Mentions == nil {
7364 fieldCount--
7365 }
7366
7367 if t.References == nil {
7368 fieldCount--
7369 }
7370
7371 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7372 return err
7373 }
7374
7375 // t.Body (string) (string)
7376 if t.Body != nil {
7377
7378 if len("body") > 1000000 {
7379 return xerrors.Errorf("Value in field \"body\" was too long")
7380 }
7381
7382 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
7383 return err
7384 }
7385 if _, err := cw.WriteString(string("body")); err != nil {
7386 return err
7387 }
7388
7389 if t.Body == nil {
7390 if _, err := cw.Write(cbg.CborNull); err != nil {
7391 return err
7392 }
7393 } else {
7394 if len(*t.Body) > 1000000 {
7395 return xerrors.Errorf("Value in field t.Body was too long")
7396 }
7397
7398 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
7399 return err
7400 }
7401 if _, err := cw.WriteString(string(*t.Body)); err != nil {
7402 return err
7403 }
7404 }
7405 }
7406
7407 // t.Repo (string) (string)
7408 if len("repo") > 1000000 {
7409 return xerrors.Errorf("Value in field \"repo\" was too long")
7410 }
7411
7412 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
7413 return err
7414 }
7415 if _, err := cw.WriteString(string("repo")); err != nil {
7416 return err
7417 }
7418
7419 if len(t.Repo) > 1000000 {
7420 return xerrors.Errorf("Value in field t.Repo was too long")
7421 }
7422
7423 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
7424 return err
7425 }
7426 if _, err := cw.WriteString(string(t.Repo)); err != nil {
7427 return err
7428 }
7429
7430 // t.LexiconTypeID (string) (string)
7431 if len("$type") > 1000000 {
7432 return xerrors.Errorf("Value in field \"$type\" was too long")
7433 }
7434
7435 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7436 return err
7437 }
7438 if _, err := cw.WriteString(string("$type")); err != nil {
7439 return err
7440 }
7441
7442 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil {
7443 return err
7444 }
7445 if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil {
7446 return err
7447 }
7448
7449 // t.Title (string) (string)
7450 if len("title") > 1000000 {
7451 return xerrors.Errorf("Value in field \"title\" was too long")
7452 }
7453
7454 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
7455 return err
7456 }
7457 if _, err := cw.WriteString(string("title")); err != nil {
7458 return err
7459 }
7460
7461 if len(t.Title) > 1000000 {
7462 return xerrors.Errorf("Value in field t.Title was too long")
7463 }
7464
7465 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
7466 return err
7467 }
7468 if _, err := cw.WriteString(string(t.Title)); err != nil {
7469 return err
7470 }
7471
7472 // t.Mentions ([]string) (slice)
7473 if t.Mentions != nil {
7474
7475 if len("mentions") > 1000000 {
7476 return xerrors.Errorf("Value in field \"mentions\" was too long")
7477 }
7478
7479 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
7480 return err
7481 }
7482 if _, err := cw.WriteString(string("mentions")); err != nil {
7483 return err
7484 }
7485
7486 if len(t.Mentions) > 8192 {
7487 return xerrors.Errorf("Slice value in field t.Mentions was too long")
7488 }
7489
7490 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
7491 return err
7492 }
7493 for _, v := range t.Mentions {
7494 if len(v) > 1000000 {
7495 return xerrors.Errorf("Value in field v was too long")
7496 }
7497
7498 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
7499 return err
7500 }
7501 if _, err := cw.WriteString(string(v)); err != nil {
7502 return err
7503 }
7504
7505 }
7506 }
7507
7508 // t.CreatedAt (string) (string)
7509 if len("createdAt") > 1000000 {
7510 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7511 }
7512
7513 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7514 return err
7515 }
7516 if _, err := cw.WriteString(string("createdAt")); err != nil {
7517 return err
7518 }
7519
7520 if len(t.CreatedAt) > 1000000 {
7521 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7522 }
7523
7524 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7525 return err
7526 }
7527 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7528 return err
7529 }
7530
7531 // t.References ([]string) (slice)
7532 if t.References != nil {
7533
7534 if len("references") > 1000000 {
7535 return xerrors.Errorf("Value in field \"references\" was too long")
7536 }
7537
7538 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
7539 return err
7540 }
7541 if _, err := cw.WriteString(string("references")); err != nil {
7542 return err
7543 }
7544
7545 if len(t.References) > 8192 {
7546 return xerrors.Errorf("Slice value in field t.References was too long")
7547 }
7548
7549 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
7550 return err
7551 }
7552 for _, v := range t.References {
7553 if len(v) > 1000000 {
7554 return xerrors.Errorf("Value in field v was too long")
7555 }
7556
7557 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
7558 return err
7559 }
7560 if _, err := cw.WriteString(string(v)); err != nil {
7561 return err
7562 }
7563
7564 }
7565 }
7566 return nil
7567}
7568
7569func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) {
7570 *t = RepoIssue{}
7571
7572 cr := cbg.NewCborReader(r)
7573
7574 maj, extra, err := cr.ReadHeader()
7575 if err != nil {
7576 return err
7577 }
7578 defer func() {
7579 if err == io.EOF {
7580 err = io.ErrUnexpectedEOF
7581 }
7582 }()
7583
7584 if maj != cbg.MajMap {
7585 return fmt.Errorf("cbor input should be of type map")
7586 }
7587
7588 if extra > cbg.MaxLength {
7589 return fmt.Errorf("RepoIssue: map struct too large (%d)", extra)
7590 }
7591
7592 n := extra
7593
7594 nameBuf := make([]byte, 10)
7595 for i := uint64(0); i < n; i++ {
7596 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7597 if err != nil {
7598 return err
7599 }
7600
7601 if !ok {
7602 // Field doesn't exist on this type, so ignore it
7603 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7604 return err
7605 }
7606 continue
7607 }
7608
7609 switch string(nameBuf[:nameLen]) {
7610 // t.Body (string) (string)
7611 case "body":
7612
7613 {
7614 b, err := cr.ReadByte()
7615 if err != nil {
7616 return err
7617 }
7618 if b != cbg.CborNull[0] {
7619 if err := cr.UnreadByte(); err != nil {
7620 return err
7621 }
7622
7623 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7624 if err != nil {
7625 return err
7626 }
7627
7628 t.Body = (*string)(&sval)
7629 }
7630 }
7631 // t.Repo (string) (string)
7632 case "repo":
7633
7634 {
7635 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7636 if err != nil {
7637 return err
7638 }
7639
7640 t.Repo = string(sval)
7641 }
7642 // t.LexiconTypeID (string) (string)
7643 case "$type":
7644
7645 {
7646 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7647 if err != nil {
7648 return err
7649 }
7650
7651 t.LexiconTypeID = string(sval)
7652 }
7653 // t.Title (string) (string)
7654 case "title":
7655
7656 {
7657 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7658 if err != nil {
7659 return err
7660 }
7661
7662 t.Title = string(sval)
7663 }
7664 // t.Mentions ([]string) (slice)
7665 case "mentions":
7666
7667 maj, extra, err = cr.ReadHeader()
7668 if err != nil {
7669 return err
7670 }
7671
7672 if extra > 8192 {
7673 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
7674 }
7675
7676 if maj != cbg.MajArray {
7677 return fmt.Errorf("expected cbor array")
7678 }
7679
7680 if extra > 0 {
7681 t.Mentions = make([]string, extra)
7682 }
7683
7684 for i := 0; i < int(extra); i++ {
7685 {
7686 var maj byte
7687 var extra uint64
7688 var err error
7689 _ = maj
7690 _ = extra
7691 _ = err
7692
7693 {
7694 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7695 if err != nil {
7696 return err
7697 }
7698
7699 t.Mentions[i] = string(sval)
7700 }
7701
7702 }
7703 }
7704 // t.CreatedAt (string) (string)
7705 case "createdAt":
7706
7707 {
7708 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7709 if err != nil {
7710 return err
7711 }
7712
7713 t.CreatedAt = string(sval)
7714 }
7715 // t.References ([]string) (slice)
7716 case "references":
7717
7718 maj, extra, err = cr.ReadHeader()
7719 if err != nil {
7720 return err
7721 }
7722
7723 if extra > 8192 {
7724 return fmt.Errorf("t.References: array too large (%d)", extra)
7725 }
7726
7727 if maj != cbg.MajArray {
7728 return fmt.Errorf("expected cbor array")
7729 }
7730
7731 if extra > 0 {
7732 t.References = make([]string, extra)
7733 }
7734
7735 for i := 0; i < int(extra); i++ {
7736 {
7737 var maj byte
7738 var extra uint64
7739 var err error
7740 _ = maj
7741 _ = extra
7742 _ = err
7743
7744 {
7745 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7746 if err != nil {
7747 return err
7748 }
7749
7750 t.References[i] = string(sval)
7751 }
7752
7753 }
7754 }
7755
7756 default:
7757 // Field doesn't exist on this type, so ignore it
7758 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7759 return err
7760 }
7761 }
7762 }
7763
7764 return nil
7765}
7766func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error {
7767 if t == nil {
7768 _, err := w.Write(cbg.CborNull)
7769 return err
7770 }
7771
7772 cw := cbg.NewCborWriter(w)
7773 fieldCount := 7
7774
7775 if t.Mentions == nil {
7776 fieldCount--
7777 }
7778
7779 if t.References == nil {
7780 fieldCount--
7781 }
7782
7783 if t.ReplyTo == nil {
7784 fieldCount--
7785 }
7786
7787 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7788 return err
7789 }
7790
7791 // t.Body (string) (string)
7792 if len("body") > 1000000 {
7793 return xerrors.Errorf("Value in field \"body\" was too long")
7794 }
7795
7796 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
7797 return err
7798 }
7799 if _, err := cw.WriteString(string("body")); err != nil {
7800 return err
7801 }
7802
7803 if len(t.Body) > 1000000 {
7804 return xerrors.Errorf("Value in field t.Body was too long")
7805 }
7806
7807 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
7808 return err
7809 }
7810 if _, err := cw.WriteString(string(t.Body)); err != nil {
7811 return err
7812 }
7813
7814 // t.LexiconTypeID (string) (string)
7815 if len("$type") > 1000000 {
7816 return xerrors.Errorf("Value in field \"$type\" was too long")
7817 }
7818
7819 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7820 return err
7821 }
7822 if _, err := cw.WriteString(string("$type")); err != nil {
7823 return err
7824 }
7825
7826 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil {
7827 return err
7828 }
7829 if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil {
7830 return err
7831 }
7832
7833 // t.Issue (string) (string)
7834 if len("issue") > 1000000 {
7835 return xerrors.Errorf("Value in field \"issue\" was too long")
7836 }
7837
7838 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
7839 return err
7840 }
7841 if _, err := cw.WriteString(string("issue")); err != nil {
7842 return err
7843 }
7844
7845 if len(t.Issue) > 1000000 {
7846 return xerrors.Errorf("Value in field t.Issue was too long")
7847 }
7848
7849 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
7850 return err
7851 }
7852 if _, err := cw.WriteString(string(t.Issue)); err != nil {
7853 return err
7854 }
7855
7856 // t.ReplyTo (string) (string)
7857 if t.ReplyTo != nil {
7858
7859 if len("replyTo") > 1000000 {
7860 return xerrors.Errorf("Value in field \"replyTo\" was too long")
7861 }
7862
7863 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("replyTo"))); err != nil {
7864 return err
7865 }
7866 if _, err := cw.WriteString(string("replyTo")); err != nil {
7867 return err
7868 }
7869
7870 if t.ReplyTo == nil {
7871 if _, err := cw.Write(cbg.CborNull); err != nil {
7872 return err
7873 }
7874 } else {
7875 if len(*t.ReplyTo) > 1000000 {
7876 return xerrors.Errorf("Value in field t.ReplyTo was too long")
7877 }
7878
7879 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ReplyTo))); err != nil {
7880 return err
7881 }
7882 if _, err := cw.WriteString(string(*t.ReplyTo)); err != nil {
7883 return err
7884 }
7885 }
7886 }
7887
7888 // t.Mentions ([]string) (slice)
7889 if t.Mentions != nil {
7890
7891 if len("mentions") > 1000000 {
7892 return xerrors.Errorf("Value in field \"mentions\" was too long")
7893 }
7894
7895 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
7896 return err
7897 }
7898 if _, err := cw.WriteString(string("mentions")); err != nil {
7899 return err
7900 }
7901
7902 if len(t.Mentions) > 8192 {
7903 return xerrors.Errorf("Slice value in field t.Mentions was too long")
7904 }
7905
7906 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
7907 return err
7908 }
7909 for _, v := range t.Mentions {
7910 if len(v) > 1000000 {
7911 return xerrors.Errorf("Value in field v was too long")
7912 }
7913
7914 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
7915 return err
7916 }
7917 if _, err := cw.WriteString(string(v)); err != nil {
7918 return err
7919 }
7920
7921 }
7922 }
7923
7924 // t.CreatedAt (string) (string)
7925 if len("createdAt") > 1000000 {
7926 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7927 }
7928
7929 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7930 return err
7931 }
7932 if _, err := cw.WriteString(string("createdAt")); err != nil {
7933 return err
7934 }
7935
7936 if len(t.CreatedAt) > 1000000 {
7937 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7938 }
7939
7940 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7941 return err
7942 }
7943 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7944 return err
7945 }
7946
7947 // t.References ([]string) (slice)
7948 if t.References != nil {
7949
7950 if len("references") > 1000000 {
7951 return xerrors.Errorf("Value in field \"references\" was too long")
7952 }
7953
7954 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
7955 return err
7956 }
7957 if _, err := cw.WriteString(string("references")); err != nil {
7958 return err
7959 }
7960
7961 if len(t.References) > 8192 {
7962 return xerrors.Errorf("Slice value in field t.References was too long")
7963 }
7964
7965 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
7966 return err
7967 }
7968 for _, v := range t.References {
7969 if len(v) > 1000000 {
7970 return xerrors.Errorf("Value in field v was too long")
7971 }
7972
7973 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
7974 return err
7975 }
7976 if _, err := cw.WriteString(string(v)); err != nil {
7977 return err
7978 }
7979
7980 }
7981 }
7982 return nil
7983}
7984
7985func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) {
7986 *t = RepoIssueComment{}
7987
7988 cr := cbg.NewCborReader(r)
7989
7990 maj, extra, err := cr.ReadHeader()
7991 if err != nil {
7992 return err
7993 }
7994 defer func() {
7995 if err == io.EOF {
7996 err = io.ErrUnexpectedEOF
7997 }
7998 }()
7999
8000 if maj != cbg.MajMap {
8001 return fmt.Errorf("cbor input should be of type map")
8002 }
8003
8004 if extra > cbg.MaxLength {
8005 return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra)
8006 }
8007
8008 n := extra
8009
8010 nameBuf := make([]byte, 10)
8011 for i := uint64(0); i < n; i++ {
8012 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8013 if err != nil {
8014 return err
8015 }
8016
8017 if !ok {
8018 // Field doesn't exist on this type, so ignore it
8019 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8020 return err
8021 }
8022 continue
8023 }
8024
8025 switch string(nameBuf[:nameLen]) {
8026 // t.Body (string) (string)
8027 case "body":
8028
8029 {
8030 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8031 if err != nil {
8032 return err
8033 }
8034
8035 t.Body = string(sval)
8036 }
8037 // t.LexiconTypeID (string) (string)
8038 case "$type":
8039
8040 {
8041 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8042 if err != nil {
8043 return err
8044 }
8045
8046 t.LexiconTypeID = string(sval)
8047 }
8048 // t.Issue (string) (string)
8049 case "issue":
8050
8051 {
8052 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8053 if err != nil {
8054 return err
8055 }
8056
8057 t.Issue = string(sval)
8058 }
8059 // t.ReplyTo (string) (string)
8060 case "replyTo":
8061
8062 {
8063 b, err := cr.ReadByte()
8064 if err != nil {
8065 return err
8066 }
8067 if b != cbg.CborNull[0] {
8068 if err := cr.UnreadByte(); err != nil {
8069 return err
8070 }
8071
8072 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8073 if err != nil {
8074 return err
8075 }
8076
8077 t.ReplyTo = (*string)(&sval)
8078 }
8079 }
8080 // t.Mentions ([]string) (slice)
8081 case "mentions":
8082
8083 maj, extra, err = cr.ReadHeader()
8084 if err != nil {
8085 return err
8086 }
8087
8088 if extra > 8192 {
8089 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
8090 }
8091
8092 if maj != cbg.MajArray {
8093 return fmt.Errorf("expected cbor array")
8094 }
8095
8096 if extra > 0 {
8097 t.Mentions = make([]string, extra)
8098 }
8099
8100 for i := 0; i < int(extra); i++ {
8101 {
8102 var maj byte
8103 var extra uint64
8104 var err error
8105 _ = maj
8106 _ = extra
8107 _ = err
8108
8109 {
8110 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8111 if err != nil {
8112 return err
8113 }
8114
8115 t.Mentions[i] = string(sval)
8116 }
8117
8118 }
8119 }
8120 // t.CreatedAt (string) (string)
8121 case "createdAt":
8122
8123 {
8124 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8125 if err != nil {
8126 return err
8127 }
8128
8129 t.CreatedAt = string(sval)
8130 }
8131 // t.References ([]string) (slice)
8132 case "references":
8133
8134 maj, extra, err = cr.ReadHeader()
8135 if err != nil {
8136 return err
8137 }
8138
8139 if extra > 8192 {
8140 return fmt.Errorf("t.References: array too large (%d)", extra)
8141 }
8142
8143 if maj != cbg.MajArray {
8144 return fmt.Errorf("expected cbor array")
8145 }
8146
8147 if extra > 0 {
8148 t.References = make([]string, extra)
8149 }
8150
8151 for i := 0; i < int(extra); i++ {
8152 {
8153 var maj byte
8154 var extra uint64
8155 var err error
8156 _ = maj
8157 _ = extra
8158 _ = err
8159
8160 {
8161 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8162 if err != nil {
8163 return err
8164 }
8165
8166 t.References[i] = string(sval)
8167 }
8168
8169 }
8170 }
8171
8172 default:
8173 // Field doesn't exist on this type, so ignore it
8174 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8175 return err
8176 }
8177 }
8178 }
8179
8180 return nil
8181}
8182func (t *RepoIssueState) MarshalCBOR(w io.Writer) error {
8183 if t == nil {
8184 _, err := w.Write(cbg.CborNull)
8185 return err
8186 }
8187
8188 cw := cbg.NewCborWriter(w)
8189
8190 if _, err := cw.Write([]byte{163}); err != nil {
8191 return err
8192 }
8193
8194 // t.LexiconTypeID (string) (string)
8195 if len("$type") > 1000000 {
8196 return xerrors.Errorf("Value in field \"$type\" was too long")
8197 }
8198
8199 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8200 return err
8201 }
8202 if _, err := cw.WriteString(string("$type")); err != nil {
8203 return err
8204 }
8205
8206 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil {
8207 return err
8208 }
8209 if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil {
8210 return err
8211 }
8212
8213 // t.Issue (string) (string)
8214 if len("issue") > 1000000 {
8215 return xerrors.Errorf("Value in field \"issue\" was too long")
8216 }
8217
8218 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
8219 return err
8220 }
8221 if _, err := cw.WriteString(string("issue")); err != nil {
8222 return err
8223 }
8224
8225 if len(t.Issue) > 1000000 {
8226 return xerrors.Errorf("Value in field t.Issue was too long")
8227 }
8228
8229 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
8230 return err
8231 }
8232 if _, err := cw.WriteString(string(t.Issue)); err != nil {
8233 return err
8234 }
8235
8236 // t.State (string) (string)
8237 if len("state") > 1000000 {
8238 return xerrors.Errorf("Value in field \"state\" was too long")
8239 }
8240
8241 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil {
8242 return err
8243 }
8244 if _, err := cw.WriteString(string("state")); err != nil {
8245 return err
8246 }
8247
8248 if len(t.State) > 1000000 {
8249 return xerrors.Errorf("Value in field t.State was too long")
8250 }
8251
8252 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil {
8253 return err
8254 }
8255 if _, err := cw.WriteString(string(t.State)); err != nil {
8256 return err
8257 }
8258 return nil
8259}
8260
8261func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) {
8262 *t = RepoIssueState{}
8263
8264 cr := cbg.NewCborReader(r)
8265
8266 maj, extra, err := cr.ReadHeader()
8267 if err != nil {
8268 return err
8269 }
8270 defer func() {
8271 if err == io.EOF {
8272 err = io.ErrUnexpectedEOF
8273 }
8274 }()
8275
8276 if maj != cbg.MajMap {
8277 return fmt.Errorf("cbor input should be of type map")
8278 }
8279
8280 if extra > cbg.MaxLength {
8281 return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra)
8282 }
8283
8284 n := extra
8285
8286 nameBuf := make([]byte, 5)
8287 for i := uint64(0); i < n; i++ {
8288 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8289 if err != nil {
8290 return err
8291 }
8292
8293 if !ok {
8294 // Field doesn't exist on this type, so ignore it
8295 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8296 return err
8297 }
8298 continue
8299 }
8300
8301 switch string(nameBuf[:nameLen]) {
8302 // t.LexiconTypeID (string) (string)
8303 case "$type":
8304
8305 {
8306 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8307 if err != nil {
8308 return err
8309 }
8310
8311 t.LexiconTypeID = string(sval)
8312 }
8313 // t.Issue (string) (string)
8314 case "issue":
8315
8316 {
8317 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8318 if err != nil {
8319 return err
8320 }
8321
8322 t.Issue = string(sval)
8323 }
8324 // t.State (string) (string)
8325 case "state":
8326
8327 {
8328 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8329 if err != nil {
8330 return err
8331 }
8332
8333 t.State = string(sval)
8334 }
8335
8336 default:
8337 // Field doesn't exist on this type, so ignore it
8338 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8339 return err
8340 }
8341 }
8342 }
8343
8344 return nil
8345}
8346func (t *RepoPull) MarshalCBOR(w io.Writer) error {
8347 if t == nil {
8348 _, err := w.Write(cbg.CborNull)
8349 return err
8350 }
8351
8352 cw := cbg.NewCborWriter(w)
8353 fieldCount := 10
8354
8355 if t.Body == nil {
8356 fieldCount--
8357 }
8358
8359 if t.Mentions == nil {
8360 fieldCount--
8361 }
8362
8363 if t.Patch == nil {
8364 fieldCount--
8365 }
8366
8367 if t.References == nil {
8368 fieldCount--
8369 }
8370
8371 if t.Source == nil {
8372 fieldCount--
8373 }
8374
8375 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
8376 return err
8377 }
8378
8379 // t.Body (string) (string)
8380 if t.Body != nil {
8381
8382 if len("body") > 1000000 {
8383 return xerrors.Errorf("Value in field \"body\" was too long")
8384 }
8385
8386 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
8387 return err
8388 }
8389 if _, err := cw.WriteString(string("body")); err != nil {
8390 return err
8391 }
8392
8393 if t.Body == nil {
8394 if _, err := cw.Write(cbg.CborNull); err != nil {
8395 return err
8396 }
8397 } else {
8398 if len(*t.Body) > 1000000 {
8399 return xerrors.Errorf("Value in field t.Body was too long")
8400 }
8401
8402 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
8403 return err
8404 }
8405 if _, err := cw.WriteString(string(*t.Body)); err != nil {
8406 return err
8407 }
8408 }
8409 }
8410
8411 // t.LexiconTypeID (string) (string)
8412 if len("$type") > 1000000 {
8413 return xerrors.Errorf("Value in field \"$type\" was too long")
8414 }
8415
8416 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8417 return err
8418 }
8419 if _, err := cw.WriteString(string("$type")); err != nil {
8420 return err
8421 }
8422
8423 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil {
8424 return err
8425 }
8426 if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil {
8427 return err
8428 }
8429
8430 // t.Patch (string) (string)
8431 if t.Patch != nil {
8432
8433 if len("patch") > 1000000 {
8434 return xerrors.Errorf("Value in field \"patch\" was too long")
8435 }
8436
8437 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil {
8438 return err
8439 }
8440 if _, err := cw.WriteString(string("patch")); err != nil {
8441 return err
8442 }
8443
8444 if t.Patch == nil {
8445 if _, err := cw.Write(cbg.CborNull); err != nil {
8446 return err
8447 }
8448 } else {
8449 if len(*t.Patch) > 1000000 {
8450 return xerrors.Errorf("Value in field t.Patch was too long")
8451 }
8452
8453 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Patch))); err != nil {
8454 return err
8455 }
8456 if _, err := cw.WriteString(string(*t.Patch)); err != nil {
8457 return err
8458 }
8459 }
8460 }
8461
8462 // t.Title (string) (string)
8463 if len("title") > 1000000 {
8464 return xerrors.Errorf("Value in field \"title\" was too long")
8465 }
8466
8467 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
8468 return err
8469 }
8470 if _, err := cw.WriteString(string("title")); err != nil {
8471 return err
8472 }
8473
8474 if len(t.Title) > 1000000 {
8475 return xerrors.Errorf("Value in field t.Title was too long")
8476 }
8477
8478 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
8479 return err
8480 }
8481 if _, err := cw.WriteString(string(t.Title)); err != nil {
8482 return err
8483 }
8484
8485 // t.Source (tangled.RepoPull_Source) (struct)
8486 if t.Source != nil {
8487
8488 if len("source") > 1000000 {
8489 return xerrors.Errorf("Value in field \"source\" was too long")
8490 }
8491
8492 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
8493 return err
8494 }
8495 if _, err := cw.WriteString(string("source")); err != nil {
8496 return err
8497 }
8498
8499 if err := t.Source.MarshalCBOR(cw); err != nil {
8500 return err
8501 }
8502 }
8503
8504 // t.Target (tangled.RepoPull_Target) (struct)
8505 if len("target") > 1000000 {
8506 return xerrors.Errorf("Value in field \"target\" was too long")
8507 }
8508
8509 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("target"))); err != nil {
8510 return err
8511 }
8512 if _, err := cw.WriteString(string("target")); err != nil {
8513 return err
8514 }
8515
8516 if err := t.Target.MarshalCBOR(cw); err != nil {
8517 return err
8518 }
8519
8520 // t.Mentions ([]string) (slice)
8521 if t.Mentions != nil {
8522
8523 if len("mentions") > 1000000 {
8524 return xerrors.Errorf("Value in field \"mentions\" was too long")
8525 }
8526
8527 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
8528 return err
8529 }
8530 if _, err := cw.WriteString(string("mentions")); err != nil {
8531 return err
8532 }
8533
8534 if len(t.Mentions) > 8192 {
8535 return xerrors.Errorf("Slice value in field t.Mentions was too long")
8536 }
8537
8538 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
8539 return err
8540 }
8541 for _, v := range t.Mentions {
8542 if len(v) > 1000000 {
8543 return xerrors.Errorf("Value in field v was too long")
8544 }
8545
8546 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
8547 return err
8548 }
8549 if _, err := cw.WriteString(string(v)); err != nil {
8550 return err
8551 }
8552
8553 }
8554 }
8555
8556 // t.CreatedAt (string) (string)
8557 if len("createdAt") > 1000000 {
8558 return xerrors.Errorf("Value in field \"createdAt\" was too long")
8559 }
8560
8561 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
8562 return err
8563 }
8564 if _, err := cw.WriteString(string("createdAt")); err != nil {
8565 return err
8566 }
8567
8568 if len(t.CreatedAt) > 1000000 {
8569 return xerrors.Errorf("Value in field t.CreatedAt was too long")
8570 }
8571
8572 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
8573 return err
8574 }
8575 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
8576 return err
8577 }
8578
8579 // t.PatchBlob (util.LexBlob) (struct)
8580 if len("patchBlob") > 1000000 {
8581 return xerrors.Errorf("Value in field \"patchBlob\" was too long")
8582 }
8583
8584 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patchBlob"))); err != nil {
8585 return err
8586 }
8587 if _, err := cw.WriteString(string("patchBlob")); err != nil {
8588 return err
8589 }
8590
8591 if err := t.PatchBlob.MarshalCBOR(cw); err != nil {
8592 return err
8593 }
8594
8595 // t.References ([]string) (slice)
8596 if t.References != nil {
8597
8598 if len("references") > 1000000 {
8599 return xerrors.Errorf("Value in field \"references\" was too long")
8600 }
8601
8602 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
8603 return err
8604 }
8605 if _, err := cw.WriteString(string("references")); err != nil {
8606 return err
8607 }
8608
8609 if len(t.References) > 8192 {
8610 return xerrors.Errorf("Slice value in field t.References was too long")
8611 }
8612
8613 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
8614 return err
8615 }
8616 for _, v := range t.References {
8617 if len(v) > 1000000 {
8618 return xerrors.Errorf("Value in field v was too long")
8619 }
8620
8621 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
8622 return err
8623 }
8624 if _, err := cw.WriteString(string(v)); err != nil {
8625 return err
8626 }
8627
8628 }
8629 }
8630 return nil
8631}
8632
8633func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) {
8634 *t = RepoPull{}
8635
8636 cr := cbg.NewCborReader(r)
8637
8638 maj, extra, err := cr.ReadHeader()
8639 if err != nil {
8640 return err
8641 }
8642 defer func() {
8643 if err == io.EOF {
8644 err = io.ErrUnexpectedEOF
8645 }
8646 }()
8647
8648 if maj != cbg.MajMap {
8649 return fmt.Errorf("cbor input should be of type map")
8650 }
8651
8652 if extra > cbg.MaxLength {
8653 return fmt.Errorf("RepoPull: map struct too large (%d)", extra)
8654 }
8655
8656 n := extra
8657
8658 nameBuf := make([]byte, 10)
8659 for i := uint64(0); i < n; i++ {
8660 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8661 if err != nil {
8662 return err
8663 }
8664
8665 if !ok {
8666 // Field doesn't exist on this type, so ignore it
8667 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8668 return err
8669 }
8670 continue
8671 }
8672
8673 switch string(nameBuf[:nameLen]) {
8674 // t.Body (string) (string)
8675 case "body":
8676
8677 {
8678 b, err := cr.ReadByte()
8679 if err != nil {
8680 return err
8681 }
8682 if b != cbg.CborNull[0] {
8683 if err := cr.UnreadByte(); err != nil {
8684 return err
8685 }
8686
8687 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8688 if err != nil {
8689 return err
8690 }
8691
8692 t.Body = (*string)(&sval)
8693 }
8694 }
8695 // t.LexiconTypeID (string) (string)
8696 case "$type":
8697
8698 {
8699 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8700 if err != nil {
8701 return err
8702 }
8703
8704 t.LexiconTypeID = string(sval)
8705 }
8706 // t.Patch (string) (string)
8707 case "patch":
8708
8709 {
8710 b, err := cr.ReadByte()
8711 if err != nil {
8712 return err
8713 }
8714 if b != cbg.CborNull[0] {
8715 if err := cr.UnreadByte(); err != nil {
8716 return err
8717 }
8718
8719 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8720 if err != nil {
8721 return err
8722 }
8723
8724 t.Patch = (*string)(&sval)
8725 }
8726 }
8727 // t.Title (string) (string)
8728 case "title":
8729
8730 {
8731 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8732 if err != nil {
8733 return err
8734 }
8735
8736 t.Title = string(sval)
8737 }
8738 // t.Source (tangled.RepoPull_Source) (struct)
8739 case "source":
8740
8741 {
8742
8743 b, err := cr.ReadByte()
8744 if err != nil {
8745 return err
8746 }
8747 if b != cbg.CborNull[0] {
8748 if err := cr.UnreadByte(); err != nil {
8749 return err
8750 }
8751 t.Source = new(RepoPull_Source)
8752 if err := t.Source.UnmarshalCBOR(cr); err != nil {
8753 return xerrors.Errorf("unmarshaling t.Source pointer: %w", err)
8754 }
8755 }
8756
8757 }
8758 // t.Target (tangled.RepoPull_Target) (struct)
8759 case "target":
8760
8761 {
8762
8763 b, err := cr.ReadByte()
8764 if err != nil {
8765 return err
8766 }
8767 if b != cbg.CborNull[0] {
8768 if err := cr.UnreadByte(); err != nil {
8769 return err
8770 }
8771 t.Target = new(RepoPull_Target)
8772 if err := t.Target.UnmarshalCBOR(cr); err != nil {
8773 return xerrors.Errorf("unmarshaling t.Target pointer: %w", err)
8774 }
8775 }
8776
8777 }
8778 // t.Mentions ([]string) (slice)
8779 case "mentions":
8780
8781 maj, extra, err = cr.ReadHeader()
8782 if err != nil {
8783 return err
8784 }
8785
8786 if extra > 8192 {
8787 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
8788 }
8789
8790 if maj != cbg.MajArray {
8791 return fmt.Errorf("expected cbor array")
8792 }
8793
8794 if extra > 0 {
8795 t.Mentions = make([]string, extra)
8796 }
8797
8798 for i := 0; i < int(extra); i++ {
8799 {
8800 var maj byte
8801 var extra uint64
8802 var err error
8803 _ = maj
8804 _ = extra
8805 _ = err
8806
8807 {
8808 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8809 if err != nil {
8810 return err
8811 }
8812
8813 t.Mentions[i] = string(sval)
8814 }
8815
8816 }
8817 }
8818 // t.CreatedAt (string) (string)
8819 case "createdAt":
8820
8821 {
8822 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8823 if err != nil {
8824 return err
8825 }
8826
8827 t.CreatedAt = string(sval)
8828 }
8829 // t.PatchBlob (util.LexBlob) (struct)
8830 case "patchBlob":
8831
8832 {
8833
8834 b, err := cr.ReadByte()
8835 if err != nil {
8836 return err
8837 }
8838 if b != cbg.CborNull[0] {
8839 if err := cr.UnreadByte(); err != nil {
8840 return err
8841 }
8842 t.PatchBlob = new(util.LexBlob)
8843 if err := t.PatchBlob.UnmarshalCBOR(cr); err != nil {
8844 return xerrors.Errorf("unmarshaling t.PatchBlob pointer: %w", err)
8845 }
8846 }
8847
8848 }
8849 // t.References ([]string) (slice)
8850 case "references":
8851
8852 maj, extra, err = cr.ReadHeader()
8853 if err != nil {
8854 return err
8855 }
8856
8857 if extra > 8192 {
8858 return fmt.Errorf("t.References: array too large (%d)", extra)
8859 }
8860
8861 if maj != cbg.MajArray {
8862 return fmt.Errorf("expected cbor array")
8863 }
8864
8865 if extra > 0 {
8866 t.References = make([]string, extra)
8867 }
8868
8869 for i := 0; i < int(extra); i++ {
8870 {
8871 var maj byte
8872 var extra uint64
8873 var err error
8874 _ = maj
8875 _ = extra
8876 _ = err
8877
8878 {
8879 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8880 if err != nil {
8881 return err
8882 }
8883
8884 t.References[i] = string(sval)
8885 }
8886
8887 }
8888 }
8889
8890 default:
8891 // Field doesn't exist on this type, so ignore it
8892 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8893 return err
8894 }
8895 }
8896 }
8897
8898 return nil
8899}
8900func (t *RepoPullComment) MarshalCBOR(w io.Writer) error {
8901 if t == nil {
8902 _, err := w.Write(cbg.CborNull)
8903 return err
8904 }
8905
8906 cw := cbg.NewCborWriter(w)
8907 fieldCount := 6
8908
8909 if t.Mentions == nil {
8910 fieldCount--
8911 }
8912
8913 if t.References == nil {
8914 fieldCount--
8915 }
8916
8917 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
8918 return err
8919 }
8920
8921 // t.Body (string) (string)
8922 if len("body") > 1000000 {
8923 return xerrors.Errorf("Value in field \"body\" was too long")
8924 }
8925
8926 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
8927 return err
8928 }
8929 if _, err := cw.WriteString(string("body")); err != nil {
8930 return err
8931 }
8932
8933 if len(t.Body) > 1000000 {
8934 return xerrors.Errorf("Value in field t.Body was too long")
8935 }
8936
8937 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
8938 return err
8939 }
8940 if _, err := cw.WriteString(string(t.Body)); err != nil {
8941 return err
8942 }
8943
8944 // t.Pull (string) (string)
8945 if len("pull") > 1000000 {
8946 return xerrors.Errorf("Value in field \"pull\" was too long")
8947 }
8948
8949 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
8950 return err
8951 }
8952 if _, err := cw.WriteString(string("pull")); err != nil {
8953 return err
8954 }
8955
8956 if len(t.Pull) > 1000000 {
8957 return xerrors.Errorf("Value in field t.Pull was too long")
8958 }
8959
8960 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
8961 return err
8962 }
8963 if _, err := cw.WriteString(string(t.Pull)); err != nil {
8964 return err
8965 }
8966
8967 // t.LexiconTypeID (string) (string)
8968 if len("$type") > 1000000 {
8969 return xerrors.Errorf("Value in field \"$type\" was too long")
8970 }
8971
8972 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8973 return err
8974 }
8975 if _, err := cw.WriteString(string("$type")); err != nil {
8976 return err
8977 }
8978
8979 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.comment"))); err != nil {
8980 return err
8981 }
8982 if _, err := cw.WriteString(string("sh.tangled.repo.pull.comment")); err != nil {
8983 return err
8984 }
8985
8986 // t.Mentions ([]string) (slice)
8987 if t.Mentions != nil {
8988
8989 if len("mentions") > 1000000 {
8990 return xerrors.Errorf("Value in field \"mentions\" was too long")
8991 }
8992
8993 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
8994 return err
8995 }
8996 if _, err := cw.WriteString(string("mentions")); err != nil {
8997 return err
8998 }
8999
9000 if len(t.Mentions) > 8192 {
9001 return xerrors.Errorf("Slice value in field t.Mentions was too long")
9002 }
9003
9004 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
9005 return err
9006 }
9007 for _, v := range t.Mentions {
9008 if len(v) > 1000000 {
9009 return xerrors.Errorf("Value in field v was too long")
9010 }
9011
9012 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
9013 return err
9014 }
9015 if _, err := cw.WriteString(string(v)); err != nil {
9016 return err
9017 }
9018
9019 }
9020 }
9021
9022 // t.CreatedAt (string) (string)
9023 if len("createdAt") > 1000000 {
9024 return xerrors.Errorf("Value in field \"createdAt\" was too long")
9025 }
9026
9027 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
9028 return err
9029 }
9030 if _, err := cw.WriteString(string("createdAt")); err != nil {
9031 return err
9032 }
9033
9034 if len(t.CreatedAt) > 1000000 {
9035 return xerrors.Errorf("Value in field t.CreatedAt was too long")
9036 }
9037
9038 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
9039 return err
9040 }
9041 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
9042 return err
9043 }
9044
9045 // t.References ([]string) (slice)
9046 if t.References != nil {
9047
9048 if len("references") > 1000000 {
9049 return xerrors.Errorf("Value in field \"references\" was too long")
9050 }
9051
9052 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
9053 return err
9054 }
9055 if _, err := cw.WriteString(string("references")); err != nil {
9056 return err
9057 }
9058
9059 if len(t.References) > 8192 {
9060 return xerrors.Errorf("Slice value in field t.References was too long")
9061 }
9062
9063 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
9064 return err
9065 }
9066 for _, v := range t.References {
9067 if len(v) > 1000000 {
9068 return xerrors.Errorf("Value in field v was too long")
9069 }
9070
9071 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
9072 return err
9073 }
9074 if _, err := cw.WriteString(string(v)); err != nil {
9075 return err
9076 }
9077
9078 }
9079 }
9080 return nil
9081}
9082
9083func (t *RepoPullComment) UnmarshalCBOR(r io.Reader) (err error) {
9084 *t = RepoPullComment{}
9085
9086 cr := cbg.NewCborReader(r)
9087
9088 maj, extra, err := cr.ReadHeader()
9089 if err != nil {
9090 return err
9091 }
9092 defer func() {
9093 if err == io.EOF {
9094 err = io.ErrUnexpectedEOF
9095 }
9096 }()
9097
9098 if maj != cbg.MajMap {
9099 return fmt.Errorf("cbor input should be of type map")
9100 }
9101
9102 if extra > cbg.MaxLength {
9103 return fmt.Errorf("RepoPullComment: map struct too large (%d)", extra)
9104 }
9105
9106 n := extra
9107
9108 nameBuf := make([]byte, 10)
9109 for i := uint64(0); i < n; i++ {
9110 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9111 if err != nil {
9112 return err
9113 }
9114
9115 if !ok {
9116 // Field doesn't exist on this type, so ignore it
9117 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9118 return err
9119 }
9120 continue
9121 }
9122
9123 switch string(nameBuf[:nameLen]) {
9124 // t.Body (string) (string)
9125 case "body":
9126
9127 {
9128 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9129 if err != nil {
9130 return err
9131 }
9132
9133 t.Body = string(sval)
9134 }
9135 // t.Pull (string) (string)
9136 case "pull":
9137
9138 {
9139 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9140 if err != nil {
9141 return err
9142 }
9143
9144 t.Pull = string(sval)
9145 }
9146 // t.LexiconTypeID (string) (string)
9147 case "$type":
9148
9149 {
9150 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9151 if err != nil {
9152 return err
9153 }
9154
9155 t.LexiconTypeID = string(sval)
9156 }
9157 // t.Mentions ([]string) (slice)
9158 case "mentions":
9159
9160 maj, extra, err = cr.ReadHeader()
9161 if err != nil {
9162 return err
9163 }
9164
9165 if extra > 8192 {
9166 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
9167 }
9168
9169 if maj != cbg.MajArray {
9170 return fmt.Errorf("expected cbor array")
9171 }
9172
9173 if extra > 0 {
9174 t.Mentions = make([]string, extra)
9175 }
9176
9177 for i := 0; i < int(extra); i++ {
9178 {
9179 var maj byte
9180 var extra uint64
9181 var err error
9182 _ = maj
9183 _ = extra
9184 _ = err
9185
9186 {
9187 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9188 if err != nil {
9189 return err
9190 }
9191
9192 t.Mentions[i] = string(sval)
9193 }
9194
9195 }
9196 }
9197 // t.CreatedAt (string) (string)
9198 case "createdAt":
9199
9200 {
9201 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9202 if err != nil {
9203 return err
9204 }
9205
9206 t.CreatedAt = string(sval)
9207 }
9208 // t.References ([]string) (slice)
9209 case "references":
9210
9211 maj, extra, err = cr.ReadHeader()
9212 if err != nil {
9213 return err
9214 }
9215
9216 if extra > 8192 {
9217 return fmt.Errorf("t.References: array too large (%d)", extra)
9218 }
9219
9220 if maj != cbg.MajArray {
9221 return fmt.Errorf("expected cbor array")
9222 }
9223
9224 if extra > 0 {
9225 t.References = make([]string, extra)
9226 }
9227
9228 for i := 0; i < int(extra); i++ {
9229 {
9230 var maj byte
9231 var extra uint64
9232 var err error
9233 _ = maj
9234 _ = extra
9235 _ = err
9236
9237 {
9238 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9239 if err != nil {
9240 return err
9241 }
9242
9243 t.References[i] = string(sval)
9244 }
9245
9246 }
9247 }
9248
9249 default:
9250 // Field doesn't exist on this type, so ignore it
9251 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9252 return err
9253 }
9254 }
9255 }
9256
9257 return nil
9258}
9259func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error {
9260 if t == nil {
9261 _, err := w.Write(cbg.CborNull)
9262 return err
9263 }
9264
9265 cw := cbg.NewCborWriter(w)
9266 fieldCount := 3
9267
9268 if t.Repo == nil {
9269 fieldCount--
9270 }
9271
9272 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
9273 return err
9274 }
9275
9276 // t.Sha (string) (string)
9277 if len("sha") > 1000000 {
9278 return xerrors.Errorf("Value in field \"sha\" was too long")
9279 }
9280
9281 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sha"))); err != nil {
9282 return err
9283 }
9284 if _, err := cw.WriteString(string("sha")); err != nil {
9285 return err
9286 }
9287
9288 if len(t.Sha) > 1000000 {
9289 return xerrors.Errorf("Value in field t.Sha was too long")
9290 }
9291
9292 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Sha))); err != nil {
9293 return err
9294 }
9295 if _, err := cw.WriteString(string(t.Sha)); err != nil {
9296 return err
9297 }
9298
9299 // t.Repo (string) (string)
9300 if t.Repo != nil {
9301
9302 if len("repo") > 1000000 {
9303 return xerrors.Errorf("Value in field \"repo\" was too long")
9304 }
9305
9306 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
9307 return err
9308 }
9309 if _, err := cw.WriteString(string("repo")); err != nil {
9310 return err
9311 }
9312
9313 if t.Repo == nil {
9314 if _, err := cw.Write(cbg.CborNull); err != nil {
9315 return err
9316 }
9317 } else {
9318 if len(*t.Repo) > 1000000 {
9319 return xerrors.Errorf("Value in field t.Repo was too long")
9320 }
9321
9322 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
9323 return err
9324 }
9325 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
9326 return err
9327 }
9328 }
9329 }
9330
9331 // t.Branch (string) (string)
9332 if len("branch") > 1000000 {
9333 return xerrors.Errorf("Value in field \"branch\" was too long")
9334 }
9335
9336 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
9337 return err
9338 }
9339 if _, err := cw.WriteString(string("branch")); err != nil {
9340 return err
9341 }
9342
9343 if len(t.Branch) > 1000000 {
9344 return xerrors.Errorf("Value in field t.Branch was too long")
9345 }
9346
9347 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
9348 return err
9349 }
9350 if _, err := cw.WriteString(string(t.Branch)); err != nil {
9351 return err
9352 }
9353 return nil
9354}
9355
9356func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) {
9357 *t = RepoPull_Source{}
9358
9359 cr := cbg.NewCborReader(r)
9360
9361 maj, extra, err := cr.ReadHeader()
9362 if err != nil {
9363 return err
9364 }
9365 defer func() {
9366 if err == io.EOF {
9367 err = io.ErrUnexpectedEOF
9368 }
9369 }()
9370
9371 if maj != cbg.MajMap {
9372 return fmt.Errorf("cbor input should be of type map")
9373 }
9374
9375 if extra > cbg.MaxLength {
9376 return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra)
9377 }
9378
9379 n := extra
9380
9381 nameBuf := make([]byte, 6)
9382 for i := uint64(0); i < n; i++ {
9383 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9384 if err != nil {
9385 return err
9386 }
9387
9388 if !ok {
9389 // Field doesn't exist on this type, so ignore it
9390 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9391 return err
9392 }
9393 continue
9394 }
9395
9396 switch string(nameBuf[:nameLen]) {
9397 // t.Sha (string) (string)
9398 case "sha":
9399
9400 {
9401 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9402 if err != nil {
9403 return err
9404 }
9405
9406 t.Sha = string(sval)
9407 }
9408 // t.Repo (string) (string)
9409 case "repo":
9410
9411 {
9412 b, err := cr.ReadByte()
9413 if err != nil {
9414 return err
9415 }
9416 if b != cbg.CborNull[0] {
9417 if err := cr.UnreadByte(); err != nil {
9418 return err
9419 }
9420
9421 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9422 if err != nil {
9423 return err
9424 }
9425
9426 t.Repo = (*string)(&sval)
9427 }
9428 }
9429 // t.Branch (string) (string)
9430 case "branch":
9431
9432 {
9433 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9434 if err != nil {
9435 return err
9436 }
9437
9438 t.Branch = string(sval)
9439 }
9440
9441 default:
9442 // Field doesn't exist on this type, so ignore it
9443 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9444 return err
9445 }
9446 }
9447 }
9448
9449 return nil
9450}
9451func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error {
9452 if t == nil {
9453 _, err := w.Write(cbg.CborNull)
9454 return err
9455 }
9456
9457 cw := cbg.NewCborWriter(w)
9458
9459 if _, err := cw.Write([]byte{163}); err != nil {
9460 return err
9461 }
9462
9463 // t.Pull (string) (string)
9464 if len("pull") > 1000000 {
9465 return xerrors.Errorf("Value in field \"pull\" was too long")
9466 }
9467
9468 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
9469 return err
9470 }
9471 if _, err := cw.WriteString(string("pull")); err != nil {
9472 return err
9473 }
9474
9475 if len(t.Pull) > 1000000 {
9476 return xerrors.Errorf("Value in field t.Pull was too long")
9477 }
9478
9479 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
9480 return err
9481 }
9482 if _, err := cw.WriteString(string(t.Pull)); err != nil {
9483 return err
9484 }
9485
9486 // t.LexiconTypeID (string) (string)
9487 if len("$type") > 1000000 {
9488 return xerrors.Errorf("Value in field \"$type\" was too long")
9489 }
9490
9491 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
9492 return err
9493 }
9494 if _, err := cw.WriteString(string("$type")); err != nil {
9495 return err
9496 }
9497
9498 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil {
9499 return err
9500 }
9501 if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil {
9502 return err
9503 }
9504
9505 // t.Status (string) (string)
9506 if len("status") > 1000000 {
9507 return xerrors.Errorf("Value in field \"status\" was too long")
9508 }
9509
9510 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
9511 return err
9512 }
9513 if _, err := cw.WriteString(string("status")); err != nil {
9514 return err
9515 }
9516
9517 if len(t.Status) > 1000000 {
9518 return xerrors.Errorf("Value in field t.Status was too long")
9519 }
9520
9521 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
9522 return err
9523 }
9524 if _, err := cw.WriteString(string(t.Status)); err != nil {
9525 return err
9526 }
9527 return nil
9528}
9529
9530func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) {
9531 *t = RepoPullStatus{}
9532
9533 cr := cbg.NewCborReader(r)
9534
9535 maj, extra, err := cr.ReadHeader()
9536 if err != nil {
9537 return err
9538 }
9539 defer func() {
9540 if err == io.EOF {
9541 err = io.ErrUnexpectedEOF
9542 }
9543 }()
9544
9545 if maj != cbg.MajMap {
9546 return fmt.Errorf("cbor input should be of type map")
9547 }
9548
9549 if extra > cbg.MaxLength {
9550 return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra)
9551 }
9552
9553 n := extra
9554
9555 nameBuf := make([]byte, 6)
9556 for i := uint64(0); i < n; i++ {
9557 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9558 if err != nil {
9559 return err
9560 }
9561
9562 if !ok {
9563 // Field doesn't exist on this type, so ignore it
9564 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9565 return err
9566 }
9567 continue
9568 }
9569
9570 switch string(nameBuf[:nameLen]) {
9571 // t.Pull (string) (string)
9572 case "pull":
9573
9574 {
9575 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9576 if err != nil {
9577 return err
9578 }
9579
9580 t.Pull = string(sval)
9581 }
9582 // t.LexiconTypeID (string) (string)
9583 case "$type":
9584
9585 {
9586 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9587 if err != nil {
9588 return err
9589 }
9590
9591 t.LexiconTypeID = string(sval)
9592 }
9593 // t.Status (string) (string)
9594 case "status":
9595
9596 {
9597 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9598 if err != nil {
9599 return err
9600 }
9601
9602 t.Status = string(sval)
9603 }
9604
9605 default:
9606 // Field doesn't exist on this type, so ignore it
9607 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9608 return err
9609 }
9610 }
9611 }
9612
9613 return nil
9614}
9615func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error {
9616 if t == nil {
9617 _, err := w.Write(cbg.CborNull)
9618 return err
9619 }
9620
9621 cw := cbg.NewCborWriter(w)
9622
9623 if _, err := cw.Write([]byte{162}); err != nil {
9624 return err
9625 }
9626
9627 // t.Repo (string) (string)
9628 if len("repo") > 1000000 {
9629 return xerrors.Errorf("Value in field \"repo\" was too long")
9630 }
9631
9632 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
9633 return err
9634 }
9635 if _, err := cw.WriteString(string("repo")); err != nil {
9636 return err
9637 }
9638
9639 if len(t.Repo) > 1000000 {
9640 return xerrors.Errorf("Value in field t.Repo was too long")
9641 }
9642
9643 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
9644 return err
9645 }
9646 if _, err := cw.WriteString(string(t.Repo)); err != nil {
9647 return err
9648 }
9649
9650 // t.Branch (string) (string)
9651 if len("branch") > 1000000 {
9652 return xerrors.Errorf("Value in field \"branch\" was too long")
9653 }
9654
9655 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
9656 return err
9657 }
9658 if _, err := cw.WriteString(string("branch")); err != nil {
9659 return err
9660 }
9661
9662 if len(t.Branch) > 1000000 {
9663 return xerrors.Errorf("Value in field t.Branch was too long")
9664 }
9665
9666 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
9667 return err
9668 }
9669 if _, err := cw.WriteString(string(t.Branch)); err != nil {
9670 return err
9671 }
9672 return nil
9673}
9674
9675func (t *RepoPull_Target) UnmarshalCBOR(r io.Reader) (err error) {
9676 *t = RepoPull_Target{}
9677
9678 cr := cbg.NewCborReader(r)
9679
9680 maj, extra, err := cr.ReadHeader()
9681 if err != nil {
9682 return err
9683 }
9684 defer func() {
9685 if err == io.EOF {
9686 err = io.ErrUnexpectedEOF
9687 }
9688 }()
9689
9690 if maj != cbg.MajMap {
9691 return fmt.Errorf("cbor input should be of type map")
9692 }
9693
9694 if extra > cbg.MaxLength {
9695 return fmt.Errorf("RepoPull_Target: map struct too large (%d)", extra)
9696 }
9697
9698 n := extra
9699
9700 nameBuf := make([]byte, 6)
9701 for i := uint64(0); i < n; i++ {
9702 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9703 if err != nil {
9704 return err
9705 }
9706
9707 if !ok {
9708 // Field doesn't exist on this type, so ignore it
9709 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9710 return err
9711 }
9712 continue
9713 }
9714
9715 switch string(nameBuf[:nameLen]) {
9716 // t.Repo (string) (string)
9717 case "repo":
9718
9719 {
9720 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9721 if err != nil {
9722 return err
9723 }
9724
9725 t.Repo = string(sval)
9726 }
9727 // t.Branch (string) (string)
9728 case "branch":
9729
9730 {
9731 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9732 if err != nil {
9733 return err
9734 }
9735
9736 t.Branch = string(sval)
9737 }
9738
9739 default:
9740 // Field doesn't exist on this type, so ignore it
9741 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9742 return err
9743 }
9744 }
9745 }
9746
9747 return nil
9748}
9749func (t *Spindle) MarshalCBOR(w io.Writer) error {
9750 if t == nil {
9751 _, err := w.Write(cbg.CborNull)
9752 return err
9753 }
9754
9755 cw := cbg.NewCborWriter(w)
9756
9757 if _, err := cw.Write([]byte{162}); err != nil {
9758 return err
9759 }
9760
9761 // t.LexiconTypeID (string) (string)
9762 if len("$type") > 1000000 {
9763 return xerrors.Errorf("Value in field \"$type\" was too long")
9764 }
9765
9766 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
9767 return err
9768 }
9769 if _, err := cw.WriteString(string("$type")); err != nil {
9770 return err
9771 }
9772
9773 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle"))); err != nil {
9774 return err
9775 }
9776 if _, err := cw.WriteString(string("sh.tangled.spindle")); err != nil {
9777 return err
9778 }
9779
9780 // t.CreatedAt (string) (string)
9781 if len("createdAt") > 1000000 {
9782 return xerrors.Errorf("Value in field \"createdAt\" was too long")
9783 }
9784
9785 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
9786 return err
9787 }
9788 if _, err := cw.WriteString(string("createdAt")); err != nil {
9789 return err
9790 }
9791
9792 if len(t.CreatedAt) > 1000000 {
9793 return xerrors.Errorf("Value in field t.CreatedAt was too long")
9794 }
9795
9796 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
9797 return err
9798 }
9799 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
9800 return err
9801 }
9802 return nil
9803}
9804
9805func (t *Spindle) UnmarshalCBOR(r io.Reader) (err error) {
9806 *t = Spindle{}
9807
9808 cr := cbg.NewCborReader(r)
9809
9810 maj, extra, err := cr.ReadHeader()
9811 if err != nil {
9812 return err
9813 }
9814 defer func() {
9815 if err == io.EOF {
9816 err = io.ErrUnexpectedEOF
9817 }
9818 }()
9819
9820 if maj != cbg.MajMap {
9821 return fmt.Errorf("cbor input should be of type map")
9822 }
9823
9824 if extra > cbg.MaxLength {
9825 return fmt.Errorf("Spindle: map struct too large (%d)", extra)
9826 }
9827
9828 n := extra
9829
9830 nameBuf := make([]byte, 9)
9831 for i := uint64(0); i < n; i++ {
9832 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9833 if err != nil {
9834 return err
9835 }
9836
9837 if !ok {
9838 // Field doesn't exist on this type, so ignore it
9839 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9840 return err
9841 }
9842 continue
9843 }
9844
9845 switch string(nameBuf[:nameLen]) {
9846 // t.LexiconTypeID (string) (string)
9847 case "$type":
9848
9849 {
9850 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9851 if err != nil {
9852 return err
9853 }
9854
9855 t.LexiconTypeID = string(sval)
9856 }
9857 // t.CreatedAt (string) (string)
9858 case "createdAt":
9859
9860 {
9861 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9862 if err != nil {
9863 return err
9864 }
9865
9866 t.CreatedAt = string(sval)
9867 }
9868
9869 default:
9870 // Field doesn't exist on this type, so ignore it
9871 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9872 return err
9873 }
9874 }
9875 }
9876
9877 return nil
9878}
9879func (t *SpindleMember) MarshalCBOR(w io.Writer) error {
9880 if t == nil {
9881 _, err := w.Write(cbg.CborNull)
9882 return err
9883 }
9884
9885 cw := cbg.NewCborWriter(w)
9886
9887 if _, err := cw.Write([]byte{164}); err != nil {
9888 return err
9889 }
9890
9891 // t.LexiconTypeID (string) (string)
9892 if len("$type") > 1000000 {
9893 return xerrors.Errorf("Value in field \"$type\" was too long")
9894 }
9895
9896 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
9897 return err
9898 }
9899 if _, err := cw.WriteString(string("$type")); err != nil {
9900 return err
9901 }
9902
9903 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle.member"))); err != nil {
9904 return err
9905 }
9906 if _, err := cw.WriteString(string("sh.tangled.spindle.member")); err != nil {
9907 return err
9908 }
9909
9910 // t.Subject (string) (string)
9911 if len("subject") > 1000000 {
9912 return xerrors.Errorf("Value in field \"subject\" was too long")
9913 }
9914
9915 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
9916 return err
9917 }
9918 if _, err := cw.WriteString(string("subject")); err != nil {
9919 return err
9920 }
9921
9922 if len(t.Subject) > 1000000 {
9923 return xerrors.Errorf("Value in field t.Subject was too long")
9924 }
9925
9926 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
9927 return err
9928 }
9929 if _, err := cw.WriteString(string(t.Subject)); err != nil {
9930 return err
9931 }
9932
9933 // t.Instance (string) (string)
9934 if len("instance") > 1000000 {
9935 return xerrors.Errorf("Value in field \"instance\" was too long")
9936 }
9937
9938 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("instance"))); err != nil {
9939 return err
9940 }
9941 if _, err := cw.WriteString(string("instance")); err != nil {
9942 return err
9943 }
9944
9945 if len(t.Instance) > 1000000 {
9946 return xerrors.Errorf("Value in field t.Instance was too long")
9947 }
9948
9949 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Instance))); err != nil {
9950 return err
9951 }
9952 if _, err := cw.WriteString(string(t.Instance)); err != nil {
9953 return err
9954 }
9955
9956 // t.CreatedAt (string) (string)
9957 if len("createdAt") > 1000000 {
9958 return xerrors.Errorf("Value in field \"createdAt\" was too long")
9959 }
9960
9961 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
9962 return err
9963 }
9964 if _, err := cw.WriteString(string("createdAt")); err != nil {
9965 return err
9966 }
9967
9968 if len(t.CreatedAt) > 1000000 {
9969 return xerrors.Errorf("Value in field t.CreatedAt was too long")
9970 }
9971
9972 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
9973 return err
9974 }
9975 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
9976 return err
9977 }
9978 return nil
9979}
9980
9981func (t *SpindleMember) UnmarshalCBOR(r io.Reader) (err error) {
9982 *t = SpindleMember{}
9983
9984 cr := cbg.NewCborReader(r)
9985
9986 maj, extra, err := cr.ReadHeader()
9987 if err != nil {
9988 return err
9989 }
9990 defer func() {
9991 if err == io.EOF {
9992 err = io.ErrUnexpectedEOF
9993 }
9994 }()
9995
9996 if maj != cbg.MajMap {
9997 return fmt.Errorf("cbor input should be of type map")
9998 }
9999
10000 if extra > cbg.MaxLength {
10001 return fmt.Errorf("SpindleMember: map struct too large (%d)", extra)
10002 }
10003
10004 n := extra
10005
10006 nameBuf := make([]byte, 9)
10007 for i := uint64(0); i < n; i++ {
10008 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
10009 if err != nil {
10010 return err
10011 }
10012
10013 if !ok {
10014 // Field doesn't exist on this type, so ignore it
10015 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
10016 return err
10017 }
10018 continue
10019 }
10020
10021 switch string(nameBuf[:nameLen]) {
10022 // t.LexiconTypeID (string) (string)
10023 case "$type":
10024
10025 {
10026 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10027 if err != nil {
10028 return err
10029 }
10030
10031 t.LexiconTypeID = string(sval)
10032 }
10033 // t.Subject (string) (string)
10034 case "subject":
10035
10036 {
10037 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10038 if err != nil {
10039 return err
10040 }
10041
10042 t.Subject = string(sval)
10043 }
10044 // t.Instance (string) (string)
10045 case "instance":
10046
10047 {
10048 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10049 if err != nil {
10050 return err
10051 }
10052
10053 t.Instance = string(sval)
10054 }
10055 // t.CreatedAt (string) (string)
10056 case "createdAt":
10057
10058 {
10059 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10060 if err != nil {
10061 return err
10062 }
10063
10064 t.CreatedAt = string(sval)
10065 }
10066
10067 default:
10068 // Field doesn't exist on this type, so ignore it
10069 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
10070 return err
10071 }
10072 }
10073 }
10074
10075 return nil
10076}
10077func (t *String) MarshalCBOR(w io.Writer) error {
10078 if t == nil {
10079 _, err := w.Write(cbg.CborNull)
10080 return err
10081 }
10082
10083 cw := cbg.NewCborWriter(w)
10084
10085 if _, err := cw.Write([]byte{165}); err != nil {
10086 return err
10087 }
10088
10089 // t.LexiconTypeID (string) (string)
10090 if len("$type") > 1000000 {
10091 return xerrors.Errorf("Value in field \"$type\" was too long")
10092 }
10093
10094 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
10095 return err
10096 }
10097 if _, err := cw.WriteString(string("$type")); err != nil {
10098 return err
10099 }
10100
10101 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.string"))); err != nil {
10102 return err
10103 }
10104 if _, err := cw.WriteString(string("sh.tangled.string")); err != nil {
10105 return err
10106 }
10107
10108 // t.Contents (string) (string)
10109 if len("contents") > 1000000 {
10110 return xerrors.Errorf("Value in field \"contents\" was too long")
10111 }
10112
10113 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("contents"))); err != nil {
10114 return err
10115 }
10116 if _, err := cw.WriteString(string("contents")); err != nil {
10117 return err
10118 }
10119
10120 if len(t.Contents) > 1000000 {
10121 return xerrors.Errorf("Value in field t.Contents was too long")
10122 }
10123
10124 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Contents))); err != nil {
10125 return err
10126 }
10127 if _, err := cw.WriteString(string(t.Contents)); err != nil {
10128 return err
10129 }
10130
10131 // t.Filename (string) (string)
10132 if len("filename") > 1000000 {
10133 return xerrors.Errorf("Value in field \"filename\" was too long")
10134 }
10135
10136 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("filename"))); err != nil {
10137 return err
10138 }
10139 if _, err := cw.WriteString(string("filename")); err != nil {
10140 return err
10141 }
10142
10143 if len(t.Filename) > 1000000 {
10144 return xerrors.Errorf("Value in field t.Filename was too long")
10145 }
10146
10147 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Filename))); err != nil {
10148 return err
10149 }
10150 if _, err := cw.WriteString(string(t.Filename)); err != nil {
10151 return err
10152 }
10153
10154 // t.CreatedAt (string) (string)
10155 if len("createdAt") > 1000000 {
10156 return xerrors.Errorf("Value in field \"createdAt\" was too long")
10157 }
10158
10159 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
10160 return err
10161 }
10162 if _, err := cw.WriteString(string("createdAt")); err != nil {
10163 return err
10164 }
10165
10166 if len(t.CreatedAt) > 1000000 {
10167 return xerrors.Errorf("Value in field t.CreatedAt was too long")
10168 }
10169
10170 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
10171 return err
10172 }
10173 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
10174 return err
10175 }
10176
10177 // t.Description (string) (string)
10178 if len("description") > 1000000 {
10179 return xerrors.Errorf("Value in field \"description\" was too long")
10180 }
10181
10182 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
10183 return err
10184 }
10185 if _, err := cw.WriteString(string("description")); err != nil {
10186 return err
10187 }
10188
10189 if len(t.Description) > 1000000 {
10190 return xerrors.Errorf("Value in field t.Description was too long")
10191 }
10192
10193 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil {
10194 return err
10195 }
10196 if _, err := cw.WriteString(string(t.Description)); err != nil {
10197 return err
10198 }
10199 return nil
10200}
10201
10202func (t *String) UnmarshalCBOR(r io.Reader) (err error) {
10203 *t = String{}
10204
10205 cr := cbg.NewCborReader(r)
10206
10207 maj, extra, err := cr.ReadHeader()
10208 if err != nil {
10209 return err
10210 }
10211 defer func() {
10212 if err == io.EOF {
10213 err = io.ErrUnexpectedEOF
10214 }
10215 }()
10216
10217 if maj != cbg.MajMap {
10218 return fmt.Errorf("cbor input should be of type map")
10219 }
10220
10221 if extra > cbg.MaxLength {
10222 return fmt.Errorf("String: map struct too large (%d)", extra)
10223 }
10224
10225 n := extra
10226
10227 nameBuf := make([]byte, 11)
10228 for i := uint64(0); i < n; i++ {
10229 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
10230 if err != nil {
10231 return err
10232 }
10233
10234 if !ok {
10235 // Field doesn't exist on this type, so ignore it
10236 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
10237 return err
10238 }
10239 continue
10240 }
10241
10242 switch string(nameBuf[:nameLen]) {
10243 // t.LexiconTypeID (string) (string)
10244 case "$type":
10245
10246 {
10247 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10248 if err != nil {
10249 return err
10250 }
10251
10252 t.LexiconTypeID = string(sval)
10253 }
10254 // t.Contents (string) (string)
10255 case "contents":
10256
10257 {
10258 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10259 if err != nil {
10260 return err
10261 }
10262
10263 t.Contents = string(sval)
10264 }
10265 // t.Filename (string) (string)
10266 case "filename":
10267
10268 {
10269 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10270 if err != nil {
10271 return err
10272 }
10273
10274 t.Filename = string(sval)
10275 }
10276 // t.CreatedAt (string) (string)
10277 case "createdAt":
10278
10279 {
10280 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10281 if err != nil {
10282 return err
10283 }
10284
10285 t.CreatedAt = string(sval)
10286 }
10287 // t.Description (string) (string)
10288 case "description":
10289
10290 {
10291 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10292 if err != nil {
10293 return err
10294 }
10295
10296 t.Description = string(sval)
10297 }
10298
10299 default:
10300 // Field doesn't exist on this type, so ignore it
10301 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
10302 return err
10303 }
10304 }
10305 }
10306
10307 return nil
10308}