tangled.org
Monorepo for Tangled
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 atproto "github.com/bluesky-social/indigo/api/atproto"
12 util "github.com/bluesky-social/indigo/lex/util"
13 cid "github.com/ipfs/go-cid"
14 cbg "github.com/whyrusleeping/cbor-gen"
15 xerrors "golang.org/x/xerrors"
16)
17
18var _ = xerrors.Errorf
19var _ = cid.Undef
20var _ = math.E
21var _ = sort.Sort
22
23func (t *ActorProfile) MarshalCBOR(w io.Writer) error {
24 if t == nil {
25 _, err := w.Write(cbg.CborNull)
26 return err
27 }
28
29 cw := cbg.NewCborWriter(w)
30 fieldCount := 10
31
32 if t.Avatar == nil {
33 fieldCount--
34 }
35
36 if t.Description == nil {
37 fieldCount--
38 }
39
40 if t.Links == nil {
41 fieldCount--
42 }
43
44 if t.Location == nil {
45 fieldCount--
46 }
47
48 if t.PinnedRepositories == nil {
49 fieldCount--
50 }
51
52 if t.PreferredHandle == nil {
53 fieldCount--
54 }
55
56 if t.Pronouns == nil {
57 fieldCount--
58 }
59
60 if t.Stats == nil {
61 fieldCount--
62 }
63
64 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
65 return err
66 }
67
68 // t.LexiconTypeID (string) (string)
69 if len("$type") > 1000000 {
70 return xerrors.Errorf("Value in field \"$type\" was too long")
71 }
72
73 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
74 return err
75 }
76 if _, err := cw.WriteString(string("$type")); err != nil {
77 return err
78 }
79
80 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.actor.profile"))); err != nil {
81 return err
82 }
83 if _, err := cw.WriteString(string("sh.tangled.actor.profile")); err != nil {
84 return err
85 }
86
87 // t.Links ([]string) (slice)
88 if t.Links != nil {
89
90 if len("links") > 1000000 {
91 return xerrors.Errorf("Value in field \"links\" was too long")
92 }
93
94 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("links"))); err != nil {
95 return err
96 }
97 if _, err := cw.WriteString(string("links")); err != nil {
98 return err
99 }
100
101 if len(t.Links) > 8192 {
102 return xerrors.Errorf("Slice value in field t.Links was too long")
103 }
104
105 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Links))); err != nil {
106 return err
107 }
108 for _, v := range t.Links {
109 if len(v) > 1000000 {
110 return xerrors.Errorf("Value in field v was too long")
111 }
112
113 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
114 return err
115 }
116 if _, err := cw.WriteString(string(v)); err != nil {
117 return err
118 }
119
120 }
121 }
122
123 // t.Stats ([]string) (slice)
124 if t.Stats != nil {
125
126 if len("stats") > 1000000 {
127 return xerrors.Errorf("Value in field \"stats\" was too long")
128 }
129
130 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("stats"))); err != nil {
131 return err
132 }
133 if _, err := cw.WriteString(string("stats")); err != nil {
134 return err
135 }
136
137 if len(t.Stats) > 8192 {
138 return xerrors.Errorf("Slice value in field t.Stats was too long")
139 }
140
141 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Stats))); err != nil {
142 return err
143 }
144 for _, v := range t.Stats {
145 if len(v) > 1000000 {
146 return xerrors.Errorf("Value in field v was too long")
147 }
148
149 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
150 return err
151 }
152 if _, err := cw.WriteString(string(v)); err != nil {
153 return err
154 }
155
156 }
157 }
158
159 // t.Avatar (util.LexBlob) (struct)
160 if t.Avatar != nil {
161
162 if len("avatar") > 1000000 {
163 return xerrors.Errorf("Value in field \"avatar\" was too long")
164 }
165
166 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("avatar"))); err != nil {
167 return err
168 }
169 if _, err := cw.WriteString(string("avatar")); err != nil {
170 return err
171 }
172
173 if err := t.Avatar.MarshalCBOR(cw); err != nil {
174 return err
175 }
176 }
177
178 // t.Bluesky (bool) (bool)
179 if len("bluesky") > 1000000 {
180 return xerrors.Errorf("Value in field \"bluesky\" was too long")
181 }
182
183 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("bluesky"))); err != nil {
184 return err
185 }
186 if _, err := cw.WriteString(string("bluesky")); err != nil {
187 return err
188 }
189
190 if err := cbg.WriteBool(w, t.Bluesky); err != nil {
191 return err
192 }
193
194 // t.Location (string) (string)
195 if t.Location != nil {
196
197 if len("location") > 1000000 {
198 return xerrors.Errorf("Value in field \"location\" was too long")
199 }
200
201 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("location"))); err != nil {
202 return err
203 }
204 if _, err := cw.WriteString(string("location")); err != nil {
205 return err
206 }
207
208 if t.Location == nil {
209 if _, err := cw.Write(cbg.CborNull); err != nil {
210 return err
211 }
212 } else {
213 if len(*t.Location) > 1000000 {
214 return xerrors.Errorf("Value in field t.Location was too long")
215 }
216
217 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Location))); err != nil {
218 return err
219 }
220 if _, err := cw.WriteString(string(*t.Location)); err != nil {
221 return err
222 }
223 }
224 }
225
226 // t.Pronouns (string) (string)
227 if t.Pronouns != nil {
228
229 if len("pronouns") > 1000000 {
230 return xerrors.Errorf("Value in field \"pronouns\" was too long")
231 }
232
233 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pronouns"))); err != nil {
234 return err
235 }
236 if _, err := cw.WriteString(string("pronouns")); err != nil {
237 return err
238 }
239
240 if t.Pronouns == nil {
241 if _, err := cw.Write(cbg.CborNull); err != nil {
242 return err
243 }
244 } else {
245 if len(*t.Pronouns) > 1000000 {
246 return xerrors.Errorf("Value in field t.Pronouns was too long")
247 }
248
249 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Pronouns))); err != nil {
250 return err
251 }
252 if _, err := cw.WriteString(string(*t.Pronouns)); err != nil {
253 return err
254 }
255 }
256 }
257
258 // t.Description (string) (string)
259 if t.Description != nil {
260
261 if len("description") > 1000000 {
262 return xerrors.Errorf("Value in field \"description\" was too long")
263 }
264
265 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
266 return err
267 }
268 if _, err := cw.WriteString(string("description")); err != nil {
269 return err
270 }
271
272 if t.Description == nil {
273 if _, err := cw.Write(cbg.CborNull); err != nil {
274 return err
275 }
276 } else {
277 if len(*t.Description) > 1000000 {
278 return xerrors.Errorf("Value in field t.Description was too long")
279 }
280
281 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
282 return err
283 }
284 if _, err := cw.WriteString(string(*t.Description)); err != nil {
285 return err
286 }
287 }
288 }
289
290 // t.PreferredHandle (string) (string)
291 if t.PreferredHandle != nil {
292
293 if len("preferredHandle") > 1000000 {
294 return xerrors.Errorf("Value in field \"preferredHandle\" was too long")
295 }
296
297 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("preferredHandle"))); err != nil {
298 return err
299 }
300 if _, err := cw.WriteString(string("preferredHandle")); err != nil {
301 return err
302 }
303
304 if t.PreferredHandle == nil {
305 if _, err := cw.Write(cbg.CborNull); err != nil {
306 return err
307 }
308 } else {
309 if len(*t.PreferredHandle) > 1000000 {
310 return xerrors.Errorf("Value in field t.PreferredHandle was too long")
311 }
312
313 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.PreferredHandle))); err != nil {
314 return err
315 }
316 if _, err := cw.WriteString(string(*t.PreferredHandle)); err != nil {
317 return err
318 }
319 }
320 }
321
322 // t.PinnedRepositories ([]string) (slice)
323 if t.PinnedRepositories != nil {
324
325 if len("pinnedRepositories") > 1000000 {
326 return xerrors.Errorf("Value in field \"pinnedRepositories\" was too long")
327 }
328
329 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pinnedRepositories"))); err != nil {
330 return err
331 }
332 if _, err := cw.WriteString(string("pinnedRepositories")); err != nil {
333 return err
334 }
335
336 if len(t.PinnedRepositories) > 8192 {
337 return xerrors.Errorf("Slice value in field t.PinnedRepositories was too long")
338 }
339
340 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.PinnedRepositories))); err != nil {
341 return err
342 }
343 for _, v := range t.PinnedRepositories {
344 if len(v) > 1000000 {
345 return xerrors.Errorf("Value in field v was too long")
346 }
347
348 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
349 return err
350 }
351 if _, err := cw.WriteString(string(v)); err != nil {
352 return err
353 }
354
355 }
356 }
357 return nil
358}
359
360func (t *ActorProfile) UnmarshalCBOR(r io.Reader) (err error) {
361 *t = ActorProfile{}
362
363 cr := cbg.NewCborReader(r)
364
365 maj, extra, err := cr.ReadHeader()
366 if err != nil {
367 return err
368 }
369 defer func() {
370 if err == io.EOF {
371 err = io.ErrUnexpectedEOF
372 }
373 }()
374
375 if maj != cbg.MajMap {
376 return fmt.Errorf("cbor input should be of type map")
377 }
378
379 if extra > cbg.MaxLength {
380 return fmt.Errorf("ActorProfile: map struct too large (%d)", extra)
381 }
382
383 n := extra
384
385 nameBuf := make([]byte, 18)
386 for i := uint64(0); i < n; i++ {
387 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
388 if err != nil {
389 return err
390 }
391
392 if !ok {
393 // Field doesn't exist on this type, so ignore it
394 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
395 return err
396 }
397 continue
398 }
399
400 switch string(nameBuf[:nameLen]) {
401 // t.LexiconTypeID (string) (string)
402 case "$type":
403
404 {
405 sval, err := cbg.ReadStringWithMax(cr, 1000000)
406 if err != nil {
407 return err
408 }
409
410 t.LexiconTypeID = string(sval)
411 }
412 // t.Links ([]string) (slice)
413 case "links":
414
415 maj, extra, err = cr.ReadHeader()
416 if err != nil {
417 return err
418 }
419
420 if extra > 8192 {
421 return fmt.Errorf("t.Links: array too large (%d)", extra)
422 }
423
424 if maj != cbg.MajArray {
425 return fmt.Errorf("expected cbor array")
426 }
427
428 if extra > 0 {
429 t.Links = make([]string, extra)
430 }
431
432 for i := 0; i < int(extra); i++ {
433 {
434 var maj byte
435 var extra uint64
436 var err error
437 _ = maj
438 _ = extra
439 _ = err
440
441 {
442 sval, err := cbg.ReadStringWithMax(cr, 1000000)
443 if err != nil {
444 return err
445 }
446
447 t.Links[i] = string(sval)
448 }
449
450 }
451 }
452 // t.Stats ([]string) (slice)
453 case "stats":
454
455 maj, extra, err = cr.ReadHeader()
456 if err != nil {
457 return err
458 }
459
460 if extra > 8192 {
461 return fmt.Errorf("t.Stats: array too large (%d)", extra)
462 }
463
464 if maj != cbg.MajArray {
465 return fmt.Errorf("expected cbor array")
466 }
467
468 if extra > 0 {
469 t.Stats = make([]string, extra)
470 }
471
472 for i := 0; i < int(extra); i++ {
473 {
474 var maj byte
475 var extra uint64
476 var err error
477 _ = maj
478 _ = extra
479 _ = err
480
481 {
482 sval, err := cbg.ReadStringWithMax(cr, 1000000)
483 if err != nil {
484 return err
485 }
486
487 t.Stats[i] = string(sval)
488 }
489
490 }
491 }
492 // t.Avatar (util.LexBlob) (struct)
493 case "avatar":
494
495 {
496
497 b, err := cr.ReadByte()
498 if err != nil {
499 return err
500 }
501 if b != cbg.CborNull[0] {
502 if err := cr.UnreadByte(); err != nil {
503 return err
504 }
505 t.Avatar = new(util.LexBlob)
506 if err := t.Avatar.UnmarshalCBOR(cr); err != nil {
507 return xerrors.Errorf("unmarshaling t.Avatar pointer: %w", err)
508 }
509 }
510
511 }
512 // t.Bluesky (bool) (bool)
513 case "bluesky":
514
515 maj, extra, err = cr.ReadHeader()
516 if err != nil {
517 return err
518 }
519 if maj != cbg.MajOther {
520 return fmt.Errorf("booleans must be major type 7")
521 }
522 switch extra {
523 case 20:
524 t.Bluesky = false
525 case 21:
526 t.Bluesky = true
527 default:
528 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
529 }
530 // t.Location (string) (string)
531 case "location":
532
533 {
534 b, err := cr.ReadByte()
535 if err != nil {
536 return err
537 }
538 if b != cbg.CborNull[0] {
539 if err := cr.UnreadByte(); err != nil {
540 return err
541 }
542
543 sval, err := cbg.ReadStringWithMax(cr, 1000000)
544 if err != nil {
545 return err
546 }
547
548 t.Location = (*string)(&sval)
549 }
550 }
551 // t.Pronouns (string) (string)
552 case "pronouns":
553
554 {
555 b, err := cr.ReadByte()
556 if err != nil {
557 return err
558 }
559 if b != cbg.CborNull[0] {
560 if err := cr.UnreadByte(); err != nil {
561 return err
562 }
563
564 sval, err := cbg.ReadStringWithMax(cr, 1000000)
565 if err != nil {
566 return err
567 }
568
569 t.Pronouns = (*string)(&sval)
570 }
571 }
572 // t.Description (string) (string)
573 case "description":
574
575 {
576 b, err := cr.ReadByte()
577 if err != nil {
578 return err
579 }
580 if b != cbg.CborNull[0] {
581 if err := cr.UnreadByte(); err != nil {
582 return err
583 }
584
585 sval, err := cbg.ReadStringWithMax(cr, 1000000)
586 if err != nil {
587 return err
588 }
589
590 t.Description = (*string)(&sval)
591 }
592 }
593 // t.PreferredHandle (string) (string)
594 case "preferredHandle":
595
596 {
597 b, err := cr.ReadByte()
598 if err != nil {
599 return err
600 }
601 if b != cbg.CborNull[0] {
602 if err := cr.UnreadByte(); err != nil {
603 return err
604 }
605
606 sval, err := cbg.ReadStringWithMax(cr, 1000000)
607 if err != nil {
608 return err
609 }
610
611 t.PreferredHandle = (*string)(&sval)
612 }
613 }
614 // t.PinnedRepositories ([]string) (slice)
615 case "pinnedRepositories":
616
617 maj, extra, err = cr.ReadHeader()
618 if err != nil {
619 return err
620 }
621
622 if extra > 8192 {
623 return fmt.Errorf("t.PinnedRepositories: array too large (%d)", extra)
624 }
625
626 if maj != cbg.MajArray {
627 return fmt.Errorf("expected cbor array")
628 }
629
630 if extra > 0 {
631 t.PinnedRepositories = make([]string, extra)
632 }
633
634 for i := 0; i < int(extra); i++ {
635 {
636 var maj byte
637 var extra uint64
638 var err error
639 _ = maj
640 _ = extra
641 _ = err
642
643 {
644 sval, err := cbg.ReadStringWithMax(cr, 1000000)
645 if err != nil {
646 return err
647 }
648
649 t.PinnedRepositories[i] = string(sval)
650 }
651
652 }
653 }
654
655 default:
656 // Field doesn't exist on this type, so ignore it
657 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
658 return err
659 }
660 }
661 }
662
663 return nil
664}
665func (t *CiPipeline) MarshalCBOR(w io.Writer) error {
666 if t == nil {
667 _, err := w.Write(cbg.CborNull)
668 return err
669 }
670
671 cw := cbg.NewCborWriter(w)
672 fieldCount := 7
673
674 if t.CreatedAt == nil {
675 fieldCount--
676 }
677
678 if t.Repo == nil {
679 fieldCount--
680 }
681
682 if t.SourceRepo == nil {
683 fieldCount--
684 }
685
686 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
687 return err
688 }
689
690 // t.Id (string) (string)
691 if len("id") > 1000000 {
692 return xerrors.Errorf("Value in field \"id\" was too long")
693 }
694
695 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("id"))); err != nil {
696 return err
697 }
698 if _, err := cw.WriteString(string("id")); err != nil {
699 return err
700 }
701
702 if len(t.Id) > 1000000 {
703 return xerrors.Errorf("Value in field t.Id was too long")
704 }
705
706 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Id))); err != nil {
707 return err
708 }
709 if _, err := cw.WriteString(string(t.Id)); err != nil {
710 return err
711 }
712
713 // t.Repo (string) (string)
714 if t.Repo != nil {
715
716 if len("repo") > 1000000 {
717 return xerrors.Errorf("Value in field \"repo\" was too long")
718 }
719
720 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
721 return err
722 }
723 if _, err := cw.WriteString(string("repo")); err != nil {
724 return err
725 }
726
727 if t.Repo == nil {
728 if _, err := cw.Write(cbg.CborNull); err != nil {
729 return err
730 }
731 } else {
732 if len(*t.Repo) > 1000000 {
733 return xerrors.Errorf("Value in field t.Repo was too long")
734 }
735
736 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
737 return err
738 }
739 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
740 return err
741 }
742 }
743 }
744
745 // t.Commit (string) (string)
746 if len("commit") > 1000000 {
747 return xerrors.Errorf("Value in field \"commit\" was too long")
748 }
749
750 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commit"))); err != nil {
751 return err
752 }
753 if _, err := cw.WriteString(string("commit")); err != nil {
754 return err
755 }
756
757 if len(t.Commit) > 1000000 {
758 return xerrors.Errorf("Value in field t.Commit was too long")
759 }
760
761 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Commit))); err != nil {
762 return err
763 }
764 if _, err := cw.WriteString(string(t.Commit)); err != nil {
765 return err
766 }
767
768 // t.Trigger (tangled.CiPipeline_Trigger) (struct)
769 if len("trigger") > 1000000 {
770 return xerrors.Errorf("Value in field \"trigger\" was too long")
771 }
772
773 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("trigger"))); err != nil {
774 return err
775 }
776 if _, err := cw.WriteString(string("trigger")); err != nil {
777 return err
778 }
779
780 if err := t.Trigger.MarshalCBOR(cw); err != nil {
781 return err
782 }
783
784 // t.CreatedAt (string) (string)
785 if t.CreatedAt != nil {
786
787 if len("createdAt") > 1000000 {
788 return xerrors.Errorf("Value in field \"createdAt\" was too long")
789 }
790
791 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
792 return err
793 }
794 if _, err := cw.WriteString(string("createdAt")); err != nil {
795 return err
796 }
797
798 if t.CreatedAt == nil {
799 if _, err := cw.Write(cbg.CborNull); err != nil {
800 return err
801 }
802 } else {
803 if len(*t.CreatedAt) > 1000000 {
804 return xerrors.Errorf("Value in field t.CreatedAt was too long")
805 }
806
807 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.CreatedAt))); err != nil {
808 return err
809 }
810 if _, err := cw.WriteString(string(*t.CreatedAt)); err != nil {
811 return err
812 }
813 }
814 }
815
816 // t.Workflows ([]*tangled.CiPipeline_Workflow) (slice)
817 if len("workflows") > 1000000 {
818 return xerrors.Errorf("Value in field \"workflows\" was too long")
819 }
820
821 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil {
822 return err
823 }
824 if _, err := cw.WriteString(string("workflows")); err != nil {
825 return err
826 }
827
828 if len(t.Workflows) > 8192 {
829 return xerrors.Errorf("Slice value in field t.Workflows was too long")
830 }
831
832 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil {
833 return err
834 }
835 for _, v := range t.Workflows {
836 if err := v.MarshalCBOR(cw); err != nil {
837 return err
838 }
839
840 }
841
842 // t.SourceRepo (string) (string)
843 if t.SourceRepo != nil {
844
845 if len("sourceRepo") > 1000000 {
846 return xerrors.Errorf("Value in field \"sourceRepo\" was too long")
847 }
848
849 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceRepo"))); err != nil {
850 return err
851 }
852 if _, err := cw.WriteString(string("sourceRepo")); err != nil {
853 return err
854 }
855
856 if t.SourceRepo == nil {
857 if _, err := cw.Write(cbg.CborNull); err != nil {
858 return err
859 }
860 } else {
861 if len(*t.SourceRepo) > 1000000 {
862 return xerrors.Errorf("Value in field t.SourceRepo was too long")
863 }
864
865 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.SourceRepo))); err != nil {
866 return err
867 }
868 if _, err := cw.WriteString(string(*t.SourceRepo)); err != nil {
869 return err
870 }
871 }
872 }
873 return nil
874}
875
876func (t *CiPipeline) UnmarshalCBOR(r io.Reader) (err error) {
877 *t = CiPipeline{}
878
879 cr := cbg.NewCborReader(r)
880
881 maj, extra, err := cr.ReadHeader()
882 if err != nil {
883 return err
884 }
885 defer func() {
886 if err == io.EOF {
887 err = io.ErrUnexpectedEOF
888 }
889 }()
890
891 if maj != cbg.MajMap {
892 return fmt.Errorf("cbor input should be of type map")
893 }
894
895 if extra > cbg.MaxLength {
896 return fmt.Errorf("CiPipeline: map struct too large (%d)", extra)
897 }
898
899 n := extra
900
901 nameBuf := make([]byte, 10)
902 for i := uint64(0); i < n; i++ {
903 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
904 if err != nil {
905 return err
906 }
907
908 if !ok {
909 // Field doesn't exist on this type, so ignore it
910 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
911 return err
912 }
913 continue
914 }
915
916 switch string(nameBuf[:nameLen]) {
917 // t.Id (string) (string)
918 case "id":
919
920 {
921 sval, err := cbg.ReadStringWithMax(cr, 1000000)
922 if err != nil {
923 return err
924 }
925
926 t.Id = string(sval)
927 }
928 // t.Repo (string) (string)
929 case "repo":
930
931 {
932 b, err := cr.ReadByte()
933 if err != nil {
934 return err
935 }
936 if b != cbg.CborNull[0] {
937 if err := cr.UnreadByte(); err != nil {
938 return err
939 }
940
941 sval, err := cbg.ReadStringWithMax(cr, 1000000)
942 if err != nil {
943 return err
944 }
945
946 t.Repo = (*string)(&sval)
947 }
948 }
949 // t.Commit (string) (string)
950 case "commit":
951
952 {
953 sval, err := cbg.ReadStringWithMax(cr, 1000000)
954 if err != nil {
955 return err
956 }
957
958 t.Commit = string(sval)
959 }
960 // t.Trigger (tangled.CiPipeline_Trigger) (struct)
961 case "trigger":
962
963 {
964
965 b, err := cr.ReadByte()
966 if err != nil {
967 return err
968 }
969 if b != cbg.CborNull[0] {
970 if err := cr.UnreadByte(); err != nil {
971 return err
972 }
973 t.Trigger = new(CiPipeline_Trigger)
974 if err := t.Trigger.UnmarshalCBOR(cr); err != nil {
975 return xerrors.Errorf("unmarshaling t.Trigger pointer: %w", err)
976 }
977 }
978
979 }
980 // t.CreatedAt (string) (string)
981 case "createdAt":
982
983 {
984 b, err := cr.ReadByte()
985 if err != nil {
986 return err
987 }
988 if b != cbg.CborNull[0] {
989 if err := cr.UnreadByte(); err != nil {
990 return err
991 }
992
993 sval, err := cbg.ReadStringWithMax(cr, 1000000)
994 if err != nil {
995 return err
996 }
997
998 t.CreatedAt = (*string)(&sval)
999 }
1000 }
1001 // t.Workflows ([]*tangled.CiPipeline_Workflow) (slice)
1002 case "workflows":
1003
1004 maj, extra, err = cr.ReadHeader()
1005 if err != nil {
1006 return err
1007 }
1008
1009 if extra > 8192 {
1010 return fmt.Errorf("t.Workflows: array too large (%d)", extra)
1011 }
1012
1013 if maj != cbg.MajArray {
1014 return fmt.Errorf("expected cbor array")
1015 }
1016
1017 if extra > 0 {
1018 t.Workflows = make([]*CiPipeline_Workflow, extra)
1019 }
1020
1021 for i := 0; i < int(extra); i++ {
1022 {
1023 var maj byte
1024 var extra uint64
1025 var err error
1026 _ = maj
1027 _ = extra
1028 _ = err
1029
1030 {
1031
1032 b, err := cr.ReadByte()
1033 if err != nil {
1034 return err
1035 }
1036 if b != cbg.CborNull[0] {
1037 if err := cr.UnreadByte(); err != nil {
1038 return err
1039 }
1040 t.Workflows[i] = new(CiPipeline_Workflow)
1041 if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil {
1042 return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err)
1043 }
1044 }
1045
1046 }
1047
1048 }
1049 }
1050 // t.SourceRepo (string) (string)
1051 case "sourceRepo":
1052
1053 {
1054 b, err := cr.ReadByte()
1055 if err != nil {
1056 return err
1057 }
1058 if b != cbg.CborNull[0] {
1059 if err := cr.UnreadByte(); err != nil {
1060 return err
1061 }
1062
1063 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1064 if err != nil {
1065 return err
1066 }
1067
1068 t.SourceRepo = (*string)(&sval)
1069 }
1070 }
1071
1072 default:
1073 // Field doesn't exist on this type, so ignore it
1074 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1075 return err
1076 }
1077 }
1078 }
1079
1080 return nil
1081}
1082func (t *CiPipeline_Trigger) MarshalCBOR(w io.Writer) error {
1083 if t == nil {
1084 _, err := w.Write(cbg.CborNull)
1085 return err
1086 }
1087
1088 cw := cbg.NewCborWriter(w)
1089
1090 if _, err := cw.Write([]byte{163}); err != nil {
1091 return err
1092 }
1093
1094 // t.CiTrigger_Push (tangled.CiTrigger_Push) (struct)
1095 if len("CiTrigger_Push") > 1000000 {
1096 return xerrors.Errorf("Value in field \"CiTrigger_Push\" was too long")
1097 }
1098
1099 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("CiTrigger_Push"))); err != nil {
1100 return err
1101 }
1102 if _, err := cw.WriteString(string("CiTrigger_Push")); err != nil {
1103 return err
1104 }
1105
1106 if err := t.CiTrigger_Push.MarshalCBOR(cw); err != nil {
1107 return err
1108 }
1109
1110 // t.CiTrigger_Manual (tangled.CiTrigger_Manual) (struct)
1111 if len("CiTrigger_Manual") > 1000000 {
1112 return xerrors.Errorf("Value in field \"CiTrigger_Manual\" was too long")
1113 }
1114
1115 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("CiTrigger_Manual"))); err != nil {
1116 return err
1117 }
1118 if _, err := cw.WriteString(string("CiTrigger_Manual")); err != nil {
1119 return err
1120 }
1121
1122 if err := t.CiTrigger_Manual.MarshalCBOR(cw); err != nil {
1123 return err
1124 }
1125
1126 // t.CiTrigger_PullRequest (tangled.CiTrigger_PullRequest) (struct)
1127 if len("CiTrigger_PullRequest") > 1000000 {
1128 return xerrors.Errorf("Value in field \"CiTrigger_PullRequest\" was too long")
1129 }
1130
1131 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("CiTrigger_PullRequest"))); err != nil {
1132 return err
1133 }
1134 if _, err := cw.WriteString(string("CiTrigger_PullRequest")); err != nil {
1135 return err
1136 }
1137
1138 if err := t.CiTrigger_PullRequest.MarshalCBOR(cw); err != nil {
1139 return err
1140 }
1141 return nil
1142}
1143
1144func (t *CiPipeline_Trigger) UnmarshalCBOR(r io.Reader) (err error) {
1145 *t = CiPipeline_Trigger{}
1146
1147 cr := cbg.NewCborReader(r)
1148
1149 maj, extra, err := cr.ReadHeader()
1150 if err != nil {
1151 return err
1152 }
1153 defer func() {
1154 if err == io.EOF {
1155 err = io.ErrUnexpectedEOF
1156 }
1157 }()
1158
1159 if maj != cbg.MajMap {
1160 return fmt.Errorf("cbor input should be of type map")
1161 }
1162
1163 if extra > cbg.MaxLength {
1164 return fmt.Errorf("CiPipeline_Trigger: map struct too large (%d)", extra)
1165 }
1166
1167 n := extra
1168
1169 nameBuf := make([]byte, 21)
1170 for i := uint64(0); i < n; i++ {
1171 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1172 if err != nil {
1173 return err
1174 }
1175
1176 if !ok {
1177 // Field doesn't exist on this type, so ignore it
1178 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1179 return err
1180 }
1181 continue
1182 }
1183
1184 switch string(nameBuf[:nameLen]) {
1185 // t.CiTrigger_Push (tangled.CiTrigger_Push) (struct)
1186 case "CiTrigger_Push":
1187
1188 {
1189
1190 b, err := cr.ReadByte()
1191 if err != nil {
1192 return err
1193 }
1194 if b != cbg.CborNull[0] {
1195 if err := cr.UnreadByte(); err != nil {
1196 return err
1197 }
1198 t.CiTrigger_Push = new(CiTrigger_Push)
1199 if err := t.CiTrigger_Push.UnmarshalCBOR(cr); err != nil {
1200 return xerrors.Errorf("unmarshaling t.CiTrigger_Push pointer: %w", err)
1201 }
1202 }
1203
1204 }
1205 // t.CiTrigger_Manual (tangled.CiTrigger_Manual) (struct)
1206 case "CiTrigger_Manual":
1207
1208 {
1209
1210 b, err := cr.ReadByte()
1211 if err != nil {
1212 return err
1213 }
1214 if b != cbg.CborNull[0] {
1215 if err := cr.UnreadByte(); err != nil {
1216 return err
1217 }
1218 t.CiTrigger_Manual = new(CiTrigger_Manual)
1219 if err := t.CiTrigger_Manual.UnmarshalCBOR(cr); err != nil {
1220 return xerrors.Errorf("unmarshaling t.CiTrigger_Manual pointer: %w", err)
1221 }
1222 }
1223
1224 }
1225 // t.CiTrigger_PullRequest (tangled.CiTrigger_PullRequest) (struct)
1226 case "CiTrigger_PullRequest":
1227
1228 {
1229
1230 b, err := cr.ReadByte()
1231 if err != nil {
1232 return err
1233 }
1234 if b != cbg.CborNull[0] {
1235 if err := cr.UnreadByte(); err != nil {
1236 return err
1237 }
1238 t.CiTrigger_PullRequest = new(CiTrigger_PullRequest)
1239 if err := t.CiTrigger_PullRequest.UnmarshalCBOR(cr); err != nil {
1240 return xerrors.Errorf("unmarshaling t.CiTrigger_PullRequest pointer: %w", err)
1241 }
1242 }
1243
1244 }
1245
1246 default:
1247 // Field doesn't exist on this type, so ignore it
1248 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1249 return err
1250 }
1251 }
1252 }
1253
1254 return nil
1255}
1256func (t *CiPipeline_Workflow) MarshalCBOR(w io.Writer) error {
1257 if t == nil {
1258 _, err := w.Write(cbg.CborNull)
1259 return err
1260 }
1261
1262 cw := cbg.NewCborWriter(w)
1263 fieldCount := 6
1264
1265 if t.Error == nil {
1266 fieldCount--
1267 }
1268
1269 if t.FinishedAt == nil {
1270 fieldCount--
1271 }
1272
1273 if t.StartedAt == nil {
1274 fieldCount--
1275 }
1276
1277 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1278 return err
1279 }
1280
1281 // t.Id (string) (string)
1282 if len("id") > 1000000 {
1283 return xerrors.Errorf("Value in field \"id\" was too long")
1284 }
1285
1286 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("id"))); err != nil {
1287 return err
1288 }
1289 if _, err := cw.WriteString(string("id")); err != nil {
1290 return err
1291 }
1292
1293 if len(t.Id) > 1000000 {
1294 return xerrors.Errorf("Value in field t.Id was too long")
1295 }
1296
1297 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Id))); err != nil {
1298 return err
1299 }
1300 if _, err := cw.WriteString(string(t.Id)); err != nil {
1301 return err
1302 }
1303
1304 // t.Name (string) (string)
1305 if len("name") > 1000000 {
1306 return xerrors.Errorf("Value in field \"name\" was too long")
1307 }
1308
1309 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
1310 return err
1311 }
1312 if _, err := cw.WriteString(string("name")); err != nil {
1313 return err
1314 }
1315
1316 if len(t.Name) > 1000000 {
1317 return xerrors.Errorf("Value in field t.Name was too long")
1318 }
1319
1320 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
1321 return err
1322 }
1323 if _, err := cw.WriteString(string(t.Name)); err != nil {
1324 return err
1325 }
1326
1327 // t.Error (string) (string)
1328 if t.Error != nil {
1329
1330 if len("error") > 1000000 {
1331 return xerrors.Errorf("Value in field \"error\" was too long")
1332 }
1333
1334 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("error"))); err != nil {
1335 return err
1336 }
1337 if _, err := cw.WriteString(string("error")); err != nil {
1338 return err
1339 }
1340
1341 if t.Error == nil {
1342 if _, err := cw.Write(cbg.CborNull); err != nil {
1343 return err
1344 }
1345 } else {
1346 if len(*t.Error) > 1000000 {
1347 return xerrors.Errorf("Value in field t.Error was too long")
1348 }
1349
1350 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Error))); err != nil {
1351 return err
1352 }
1353 if _, err := cw.WriteString(string(*t.Error)); err != nil {
1354 return err
1355 }
1356 }
1357 }
1358
1359 // t.Status (string) (string)
1360 if len("status") > 1000000 {
1361 return xerrors.Errorf("Value in field \"status\" was too long")
1362 }
1363
1364 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
1365 return err
1366 }
1367 if _, err := cw.WriteString(string("status")); err != nil {
1368 return err
1369 }
1370
1371 if len(t.Status) > 1000000 {
1372 return xerrors.Errorf("Value in field t.Status was too long")
1373 }
1374
1375 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
1376 return err
1377 }
1378 if _, err := cw.WriteString(string(t.Status)); err != nil {
1379 return err
1380 }
1381
1382 // t.StartedAt (string) (string)
1383 if t.StartedAt != nil {
1384
1385 if len("startedAt") > 1000000 {
1386 return xerrors.Errorf("Value in field \"startedAt\" was too long")
1387 }
1388
1389 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("startedAt"))); err != nil {
1390 return err
1391 }
1392 if _, err := cw.WriteString(string("startedAt")); err != nil {
1393 return err
1394 }
1395
1396 if t.StartedAt == nil {
1397 if _, err := cw.Write(cbg.CborNull); err != nil {
1398 return err
1399 }
1400 } else {
1401 if len(*t.StartedAt) > 1000000 {
1402 return xerrors.Errorf("Value in field t.StartedAt was too long")
1403 }
1404
1405 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.StartedAt))); err != nil {
1406 return err
1407 }
1408 if _, err := cw.WriteString(string(*t.StartedAt)); err != nil {
1409 return err
1410 }
1411 }
1412 }
1413
1414 // t.FinishedAt (string) (string)
1415 if t.FinishedAt != nil {
1416
1417 if len("finishedAt") > 1000000 {
1418 return xerrors.Errorf("Value in field \"finishedAt\" was too long")
1419 }
1420
1421 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("finishedAt"))); err != nil {
1422 return err
1423 }
1424 if _, err := cw.WriteString(string("finishedAt")); err != nil {
1425 return err
1426 }
1427
1428 if t.FinishedAt == nil {
1429 if _, err := cw.Write(cbg.CborNull); err != nil {
1430 return err
1431 }
1432 } else {
1433 if len(*t.FinishedAt) > 1000000 {
1434 return xerrors.Errorf("Value in field t.FinishedAt was too long")
1435 }
1436
1437 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.FinishedAt))); err != nil {
1438 return err
1439 }
1440 if _, err := cw.WriteString(string(*t.FinishedAt)); err != nil {
1441 return err
1442 }
1443 }
1444 }
1445 return nil
1446}
1447
1448func (t *CiPipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) {
1449 *t = CiPipeline_Workflow{}
1450
1451 cr := cbg.NewCborReader(r)
1452
1453 maj, extra, err := cr.ReadHeader()
1454 if err != nil {
1455 return err
1456 }
1457 defer func() {
1458 if err == io.EOF {
1459 err = io.ErrUnexpectedEOF
1460 }
1461 }()
1462
1463 if maj != cbg.MajMap {
1464 return fmt.Errorf("cbor input should be of type map")
1465 }
1466
1467 if extra > cbg.MaxLength {
1468 return fmt.Errorf("CiPipeline_Workflow: map struct too large (%d)", extra)
1469 }
1470
1471 n := extra
1472
1473 nameBuf := make([]byte, 10)
1474 for i := uint64(0); i < n; i++ {
1475 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1476 if err != nil {
1477 return err
1478 }
1479
1480 if !ok {
1481 // Field doesn't exist on this type, so ignore it
1482 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1483 return err
1484 }
1485 continue
1486 }
1487
1488 switch string(nameBuf[:nameLen]) {
1489 // t.Id (string) (string)
1490 case "id":
1491
1492 {
1493 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1494 if err != nil {
1495 return err
1496 }
1497
1498 t.Id = string(sval)
1499 }
1500 // t.Name (string) (string)
1501 case "name":
1502
1503 {
1504 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1505 if err != nil {
1506 return err
1507 }
1508
1509 t.Name = string(sval)
1510 }
1511 // t.Error (string) (string)
1512 case "error":
1513
1514 {
1515 b, err := cr.ReadByte()
1516 if err != nil {
1517 return err
1518 }
1519 if b != cbg.CborNull[0] {
1520 if err := cr.UnreadByte(); err != nil {
1521 return err
1522 }
1523
1524 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1525 if err != nil {
1526 return err
1527 }
1528
1529 t.Error = (*string)(&sval)
1530 }
1531 }
1532 // t.Status (string) (string)
1533 case "status":
1534
1535 {
1536 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1537 if err != nil {
1538 return err
1539 }
1540
1541 t.Status = string(sval)
1542 }
1543 // t.StartedAt (string) (string)
1544 case "startedAt":
1545
1546 {
1547 b, err := cr.ReadByte()
1548 if err != nil {
1549 return err
1550 }
1551 if b != cbg.CborNull[0] {
1552 if err := cr.UnreadByte(); err != nil {
1553 return err
1554 }
1555
1556 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1557 if err != nil {
1558 return err
1559 }
1560
1561 t.StartedAt = (*string)(&sval)
1562 }
1563 }
1564 // t.FinishedAt (string) (string)
1565 case "finishedAt":
1566
1567 {
1568 b, err := cr.ReadByte()
1569 if err != nil {
1570 return err
1571 }
1572 if b != cbg.CborNull[0] {
1573 if err := cr.UnreadByte(); err != nil {
1574 return err
1575 }
1576
1577 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1578 if err != nil {
1579 return err
1580 }
1581
1582 t.FinishedAt = (*string)(&sval)
1583 }
1584 }
1585
1586 default:
1587 // Field doesn't exist on this type, so ignore it
1588 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1589 return err
1590 }
1591 }
1592 }
1593
1594 return nil
1595}
1596func (t *CiSubscribePipelineLogs_Control) MarshalCBOR(w io.Writer) error {
1597 if t == nil {
1598 _, err := w.Write(cbg.CborNull)
1599 return err
1600 }
1601
1602 cw := cbg.NewCborWriter(w)
1603 fieldCount := 7
1604
1605 if t.Command == nil {
1606 fieldCount--
1607 }
1608
1609 if t.Kind == nil {
1610 fieldCount--
1611 }
1612
1613 if t.Status == nil {
1614 fieldCount--
1615 }
1616
1617 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1618 return err
1619 }
1620
1621 // t.Kind (string) (string)
1622 if t.Kind != nil {
1623
1624 if len("kind") > 1000000 {
1625 return xerrors.Errorf("Value in field \"kind\" was too long")
1626 }
1627
1628 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("kind"))); err != nil {
1629 return err
1630 }
1631 if _, err := cw.WriteString(string("kind")); err != nil {
1632 return err
1633 }
1634
1635 if t.Kind == nil {
1636 if _, err := cw.Write(cbg.CborNull); err != nil {
1637 return err
1638 }
1639 } else {
1640 if len(*t.Kind) > 1000000 {
1641 return xerrors.Errorf("Value in field t.Kind was too long")
1642 }
1643
1644 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Kind))); err != nil {
1645 return err
1646 }
1647 if _, err := cw.WriteString(string(*t.Kind)); err != nil {
1648 return err
1649 }
1650 }
1651 }
1652
1653 // t.Step (int64) (int64)
1654 if len("step") > 1000000 {
1655 return xerrors.Errorf("Value in field \"step\" was too long")
1656 }
1657
1658 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("step"))); err != nil {
1659 return err
1660 }
1661 if _, err := cw.WriteString(string("step")); err != nil {
1662 return err
1663 }
1664
1665 if t.Step >= 0 {
1666 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Step)); err != nil {
1667 return err
1668 }
1669 } else {
1670 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Step-1)); err != nil {
1671 return err
1672 }
1673 }
1674
1675 // t.Time (string) (string)
1676 if len("time") > 1000000 {
1677 return xerrors.Errorf("Value in field \"time\" was too long")
1678 }
1679
1680 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("time"))); err != nil {
1681 return err
1682 }
1683 if _, err := cw.WriteString(string("time")); err != nil {
1684 return err
1685 }
1686
1687 if len(t.Time) > 1000000 {
1688 return xerrors.Errorf("Value in field t.Time was too long")
1689 }
1690
1691 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Time))); err != nil {
1692 return err
1693 }
1694 if _, err := cw.WriteString(string(t.Time)); err != nil {
1695 return err
1696 }
1697
1698 // t.Status (string) (string)
1699 if t.Status != nil {
1700
1701 if len("status") > 1000000 {
1702 return xerrors.Errorf("Value in field \"status\" was too long")
1703 }
1704
1705 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
1706 return err
1707 }
1708 if _, err := cw.WriteString(string("status")); err != nil {
1709 return err
1710 }
1711
1712 if t.Status == nil {
1713 if _, err := cw.Write(cbg.CborNull); err != nil {
1714 return err
1715 }
1716 } else {
1717 if len(*t.Status) > 1000000 {
1718 return xerrors.Errorf("Value in field t.Status was too long")
1719 }
1720
1721 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Status))); err != nil {
1722 return err
1723 }
1724 if _, err := cw.WriteString(string(*t.Status)); err != nil {
1725 return err
1726 }
1727 }
1728 }
1729
1730 // t.Command (string) (string)
1731 if t.Command != nil {
1732
1733 if len("command") > 1000000 {
1734 return xerrors.Errorf("Value in field \"command\" was too long")
1735 }
1736
1737 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("command"))); err != nil {
1738 return err
1739 }
1740 if _, err := cw.WriteString(string("command")); err != nil {
1741 return err
1742 }
1743
1744 if t.Command == nil {
1745 if _, err := cw.Write(cbg.CborNull); err != nil {
1746 return err
1747 }
1748 } else {
1749 if len(*t.Command) > 1000000 {
1750 return xerrors.Errorf("Value in field t.Command was too long")
1751 }
1752
1753 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Command))); err != nil {
1754 return err
1755 }
1756 if _, err := cw.WriteString(string(*t.Command)); err != nil {
1757 return err
1758 }
1759 }
1760 }
1761
1762 // t.Content (string) (string)
1763 if len("content") > 1000000 {
1764 return xerrors.Errorf("Value in field \"content\" was too long")
1765 }
1766
1767 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("content"))); err != nil {
1768 return err
1769 }
1770 if _, err := cw.WriteString(string("content")); err != nil {
1771 return err
1772 }
1773
1774 if len(t.Content) > 1000000 {
1775 return xerrors.Errorf("Value in field t.Content was too long")
1776 }
1777
1778 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Content))); err != nil {
1779 return err
1780 }
1781 if _, err := cw.WriteString(string(t.Content)); err != nil {
1782 return err
1783 }
1784
1785 // t.Workflow (string) (string)
1786 if len("workflow") > 1000000 {
1787 return xerrors.Errorf("Value in field \"workflow\" was too long")
1788 }
1789
1790 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil {
1791 return err
1792 }
1793 if _, err := cw.WriteString(string("workflow")); err != nil {
1794 return err
1795 }
1796
1797 if len(t.Workflow) > 1000000 {
1798 return xerrors.Errorf("Value in field t.Workflow was too long")
1799 }
1800
1801 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil {
1802 return err
1803 }
1804 if _, err := cw.WriteString(string(t.Workflow)); err != nil {
1805 return err
1806 }
1807 return nil
1808}
1809
1810func (t *CiSubscribePipelineLogs_Control) UnmarshalCBOR(r io.Reader) (err error) {
1811 *t = CiSubscribePipelineLogs_Control{}
1812
1813 cr := cbg.NewCborReader(r)
1814
1815 maj, extra, err := cr.ReadHeader()
1816 if err != nil {
1817 return err
1818 }
1819 defer func() {
1820 if err == io.EOF {
1821 err = io.ErrUnexpectedEOF
1822 }
1823 }()
1824
1825 if maj != cbg.MajMap {
1826 return fmt.Errorf("cbor input should be of type map")
1827 }
1828
1829 if extra > cbg.MaxLength {
1830 return fmt.Errorf("CiSubscribePipelineLogs_Control: map struct too large (%d)", extra)
1831 }
1832
1833 n := extra
1834
1835 nameBuf := make([]byte, 8)
1836 for i := uint64(0); i < n; i++ {
1837 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1838 if err != nil {
1839 return err
1840 }
1841
1842 if !ok {
1843 // Field doesn't exist on this type, so ignore it
1844 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1845 return err
1846 }
1847 continue
1848 }
1849
1850 switch string(nameBuf[:nameLen]) {
1851 // t.Kind (string) (string)
1852 case "kind":
1853
1854 {
1855 b, err := cr.ReadByte()
1856 if err != nil {
1857 return err
1858 }
1859 if b != cbg.CborNull[0] {
1860 if err := cr.UnreadByte(); err != nil {
1861 return err
1862 }
1863
1864 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1865 if err != nil {
1866 return err
1867 }
1868
1869 t.Kind = (*string)(&sval)
1870 }
1871 }
1872 // t.Step (int64) (int64)
1873 case "step":
1874 {
1875 maj, extra, err := cr.ReadHeader()
1876 if err != nil {
1877 return err
1878 }
1879 var extraI int64
1880 switch maj {
1881 case cbg.MajUnsignedInt:
1882 extraI = int64(extra)
1883 if extraI < 0 {
1884 return fmt.Errorf("int64 positive overflow")
1885 }
1886 case cbg.MajNegativeInt:
1887 extraI = int64(extra)
1888 if extraI < 0 {
1889 return fmt.Errorf("int64 negative overflow")
1890 }
1891 extraI = -1 - extraI
1892 default:
1893 return fmt.Errorf("wrong type for int64 field: %d", maj)
1894 }
1895
1896 t.Step = int64(extraI)
1897 }
1898 // t.Time (string) (string)
1899 case "time":
1900
1901 {
1902 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1903 if err != nil {
1904 return err
1905 }
1906
1907 t.Time = string(sval)
1908 }
1909 // t.Status (string) (string)
1910 case "status":
1911
1912 {
1913 b, err := cr.ReadByte()
1914 if err != nil {
1915 return err
1916 }
1917 if b != cbg.CborNull[0] {
1918 if err := cr.UnreadByte(); err != nil {
1919 return err
1920 }
1921
1922 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1923 if err != nil {
1924 return err
1925 }
1926
1927 t.Status = (*string)(&sval)
1928 }
1929 }
1930 // t.Command (string) (string)
1931 case "command":
1932
1933 {
1934 b, err := cr.ReadByte()
1935 if err != nil {
1936 return err
1937 }
1938 if b != cbg.CborNull[0] {
1939 if err := cr.UnreadByte(); err != nil {
1940 return err
1941 }
1942
1943 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1944 if err != nil {
1945 return err
1946 }
1947
1948 t.Command = (*string)(&sval)
1949 }
1950 }
1951 // t.Content (string) (string)
1952 case "content":
1953
1954 {
1955 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1956 if err != nil {
1957 return err
1958 }
1959
1960 t.Content = string(sval)
1961 }
1962 // t.Workflow (string) (string)
1963 case "workflow":
1964
1965 {
1966 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1967 if err != nil {
1968 return err
1969 }
1970
1971 t.Workflow = string(sval)
1972 }
1973
1974 default:
1975 // Field doesn't exist on this type, so ignore it
1976 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1977 return err
1978 }
1979 }
1980 }
1981
1982 return nil
1983}
1984func (t *CiSubscribePipelineLogs_Data) MarshalCBOR(w io.Writer) error {
1985 if t == nil {
1986 _, err := w.Write(cbg.CborNull)
1987 return err
1988 }
1989
1990 cw := cbg.NewCborWriter(w)
1991
1992 if _, err := cw.Write([]byte{165}); err != nil {
1993 return err
1994 }
1995
1996 // t.Step (int64) (int64)
1997 if len("step") > 1000000 {
1998 return xerrors.Errorf("Value in field \"step\" was too long")
1999 }
2000
2001 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("step"))); err != nil {
2002 return err
2003 }
2004 if _, err := cw.WriteString(string("step")); err != nil {
2005 return err
2006 }
2007
2008 if t.Step >= 0 {
2009 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Step)); err != nil {
2010 return err
2011 }
2012 } else {
2013 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Step-1)); err != nil {
2014 return err
2015 }
2016 }
2017
2018 // t.Time (string) (string)
2019 if len("time") > 1000000 {
2020 return xerrors.Errorf("Value in field \"time\" was too long")
2021 }
2022
2023 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("time"))); err != nil {
2024 return err
2025 }
2026 if _, err := cw.WriteString(string("time")); err != nil {
2027 return err
2028 }
2029
2030 if len(t.Time) > 1000000 {
2031 return xerrors.Errorf("Value in field t.Time was too long")
2032 }
2033
2034 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Time))); err != nil {
2035 return err
2036 }
2037 if _, err := cw.WriteString(string(t.Time)); err != nil {
2038 return err
2039 }
2040
2041 // t.Stream (string) (string)
2042 if len("stream") > 1000000 {
2043 return xerrors.Errorf("Value in field \"stream\" was too long")
2044 }
2045
2046 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("stream"))); err != nil {
2047 return err
2048 }
2049 if _, err := cw.WriteString(string("stream")); err != nil {
2050 return err
2051 }
2052
2053 if len(t.Stream) > 1000000 {
2054 return xerrors.Errorf("Value in field t.Stream was too long")
2055 }
2056
2057 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Stream))); err != nil {
2058 return err
2059 }
2060 if _, err := cw.WriteString(string(t.Stream)); err != nil {
2061 return err
2062 }
2063
2064 // t.Content (string) (string)
2065 if len("content") > 1000000 {
2066 return xerrors.Errorf("Value in field \"content\" was too long")
2067 }
2068
2069 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("content"))); err != nil {
2070 return err
2071 }
2072 if _, err := cw.WriteString(string("content")); err != nil {
2073 return err
2074 }
2075
2076 if len(t.Content) > 1000000 {
2077 return xerrors.Errorf("Value in field t.Content was too long")
2078 }
2079
2080 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Content))); err != nil {
2081 return err
2082 }
2083 if _, err := cw.WriteString(string(t.Content)); err != nil {
2084 return err
2085 }
2086
2087 // t.Workflow (string) (string)
2088 if len("workflow") > 1000000 {
2089 return xerrors.Errorf("Value in field \"workflow\" was too long")
2090 }
2091
2092 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil {
2093 return err
2094 }
2095 if _, err := cw.WriteString(string("workflow")); err != nil {
2096 return err
2097 }
2098
2099 if len(t.Workflow) > 1000000 {
2100 return xerrors.Errorf("Value in field t.Workflow was too long")
2101 }
2102
2103 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil {
2104 return err
2105 }
2106 if _, err := cw.WriteString(string(t.Workflow)); err != nil {
2107 return err
2108 }
2109 return nil
2110}
2111
2112func (t *CiSubscribePipelineLogs_Data) UnmarshalCBOR(r io.Reader) (err error) {
2113 *t = CiSubscribePipelineLogs_Data{}
2114
2115 cr := cbg.NewCborReader(r)
2116
2117 maj, extra, err := cr.ReadHeader()
2118 if err != nil {
2119 return err
2120 }
2121 defer func() {
2122 if err == io.EOF {
2123 err = io.ErrUnexpectedEOF
2124 }
2125 }()
2126
2127 if maj != cbg.MajMap {
2128 return fmt.Errorf("cbor input should be of type map")
2129 }
2130
2131 if extra > cbg.MaxLength {
2132 return fmt.Errorf("CiSubscribePipelineLogs_Data: map struct too large (%d)", extra)
2133 }
2134
2135 n := extra
2136
2137 nameBuf := make([]byte, 8)
2138 for i := uint64(0); i < n; i++ {
2139 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2140 if err != nil {
2141 return err
2142 }
2143
2144 if !ok {
2145 // Field doesn't exist on this type, so ignore it
2146 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2147 return err
2148 }
2149 continue
2150 }
2151
2152 switch string(nameBuf[:nameLen]) {
2153 // t.Step (int64) (int64)
2154 case "step":
2155 {
2156 maj, extra, err := cr.ReadHeader()
2157 if err != nil {
2158 return err
2159 }
2160 var extraI int64
2161 switch maj {
2162 case cbg.MajUnsignedInt:
2163 extraI = int64(extra)
2164 if extraI < 0 {
2165 return fmt.Errorf("int64 positive overflow")
2166 }
2167 case cbg.MajNegativeInt:
2168 extraI = int64(extra)
2169 if extraI < 0 {
2170 return fmt.Errorf("int64 negative overflow")
2171 }
2172 extraI = -1 - extraI
2173 default:
2174 return fmt.Errorf("wrong type for int64 field: %d", maj)
2175 }
2176
2177 t.Step = int64(extraI)
2178 }
2179 // t.Time (string) (string)
2180 case "time":
2181
2182 {
2183 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2184 if err != nil {
2185 return err
2186 }
2187
2188 t.Time = string(sval)
2189 }
2190 // t.Stream (string) (string)
2191 case "stream":
2192
2193 {
2194 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2195 if err != nil {
2196 return err
2197 }
2198
2199 t.Stream = string(sval)
2200 }
2201 // t.Content (string) (string)
2202 case "content":
2203
2204 {
2205 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2206 if err != nil {
2207 return err
2208 }
2209
2210 t.Content = string(sval)
2211 }
2212 // t.Workflow (string) (string)
2213 case "workflow":
2214
2215 {
2216 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2217 if err != nil {
2218 return err
2219 }
2220
2221 t.Workflow = string(sval)
2222 }
2223
2224 default:
2225 // Field doesn't exist on this type, so ignore it
2226 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2227 return err
2228 }
2229 }
2230 }
2231
2232 return nil
2233}
2234func (t *CiTrigger_Manual) MarshalCBOR(w io.Writer) error {
2235 if t == nil {
2236 _, err := w.Write(cbg.CborNull)
2237 return err
2238 }
2239
2240 cw := cbg.NewCborWriter(w)
2241 fieldCount := 5
2242
2243 if t.Inputs == nil {
2244 fieldCount--
2245 }
2246
2247 if t.Ref == nil {
2248 fieldCount--
2249 }
2250
2251 if t.SourceRepo == nil {
2252 fieldCount--
2253 }
2254
2255 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2256 return err
2257 }
2258
2259 // t.Ref (string) (string)
2260 if t.Ref != nil {
2261
2262 if len("ref") > 1000000 {
2263 return xerrors.Errorf("Value in field \"ref\" was too long")
2264 }
2265
2266 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
2267 return err
2268 }
2269 if _, err := cw.WriteString(string("ref")); err != nil {
2270 return err
2271 }
2272
2273 if t.Ref == nil {
2274 if _, err := cw.Write(cbg.CborNull); err != nil {
2275 return err
2276 }
2277 } else {
2278 if len(*t.Ref) > 1000000 {
2279 return xerrors.Errorf("Value in field t.Ref was too long")
2280 }
2281
2282 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Ref))); err != nil {
2283 return err
2284 }
2285 if _, err := cw.WriteString(string(*t.Ref)); err != nil {
2286 return err
2287 }
2288 }
2289 }
2290
2291 // t.Sha (string) (string)
2292 if len("sha") > 1000000 {
2293 return xerrors.Errorf("Value in field \"sha\" was too long")
2294 }
2295
2296 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sha"))); err != nil {
2297 return err
2298 }
2299 if _, err := cw.WriteString(string("sha")); err != nil {
2300 return err
2301 }
2302
2303 if len(t.Sha) > 1000000 {
2304 return xerrors.Errorf("Value in field t.Sha was too long")
2305 }
2306
2307 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Sha))); err != nil {
2308 return err
2309 }
2310 if _, err := cw.WriteString(string(t.Sha)); err != nil {
2311 return err
2312 }
2313
2314 // t.LexiconTypeID (string) (string)
2315 if len("$type") > 1000000 {
2316 return xerrors.Errorf("Value in field \"$type\" was too long")
2317 }
2318
2319 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2320 return err
2321 }
2322 if _, err := cw.WriteString(string("$type")); err != nil {
2323 return err
2324 }
2325
2326 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.ci.trigger#manual"))); err != nil {
2327 return err
2328 }
2329 if _, err := cw.WriteString(string("sh.tangled.ci.trigger#manual")); err != nil {
2330 return err
2331 }
2332
2333 // t.Inputs ([]*tangled.CiTrigger_Pair) (slice)
2334 if t.Inputs != nil {
2335
2336 if len("inputs") > 1000000 {
2337 return xerrors.Errorf("Value in field \"inputs\" was too long")
2338 }
2339
2340 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
2341 return err
2342 }
2343 if _, err := cw.WriteString(string("inputs")); err != nil {
2344 return err
2345 }
2346
2347 if len(t.Inputs) > 8192 {
2348 return xerrors.Errorf("Slice value in field t.Inputs was too long")
2349 }
2350
2351 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
2352 return err
2353 }
2354 for _, v := range t.Inputs {
2355 if err := v.MarshalCBOR(cw); err != nil {
2356 return err
2357 }
2358
2359 }
2360 }
2361
2362 // t.SourceRepo (string) (string)
2363 if t.SourceRepo != nil {
2364
2365 if len("sourceRepo") > 1000000 {
2366 return xerrors.Errorf("Value in field \"sourceRepo\" was too long")
2367 }
2368
2369 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceRepo"))); err != nil {
2370 return err
2371 }
2372 if _, err := cw.WriteString(string("sourceRepo")); err != nil {
2373 return err
2374 }
2375
2376 if t.SourceRepo == nil {
2377 if _, err := cw.Write(cbg.CborNull); err != nil {
2378 return err
2379 }
2380 } else {
2381 if len(*t.SourceRepo) > 1000000 {
2382 return xerrors.Errorf("Value in field t.SourceRepo was too long")
2383 }
2384
2385 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.SourceRepo))); err != nil {
2386 return err
2387 }
2388 if _, err := cw.WriteString(string(*t.SourceRepo)); err != nil {
2389 return err
2390 }
2391 }
2392 }
2393 return nil
2394}
2395
2396func (t *CiTrigger_Manual) UnmarshalCBOR(r io.Reader) (err error) {
2397 *t = CiTrigger_Manual{}
2398
2399 cr := cbg.NewCborReader(r)
2400
2401 maj, extra, err := cr.ReadHeader()
2402 if err != nil {
2403 return err
2404 }
2405 defer func() {
2406 if err == io.EOF {
2407 err = io.ErrUnexpectedEOF
2408 }
2409 }()
2410
2411 if maj != cbg.MajMap {
2412 return fmt.Errorf("cbor input should be of type map")
2413 }
2414
2415 if extra > cbg.MaxLength {
2416 return fmt.Errorf("CiTrigger_Manual: map struct too large (%d)", extra)
2417 }
2418
2419 n := extra
2420
2421 nameBuf := make([]byte, 10)
2422 for i := uint64(0); i < n; i++ {
2423 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2424 if err != nil {
2425 return err
2426 }
2427
2428 if !ok {
2429 // Field doesn't exist on this type, so ignore it
2430 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2431 return err
2432 }
2433 continue
2434 }
2435
2436 switch string(nameBuf[:nameLen]) {
2437 // t.Ref (string) (string)
2438 case "ref":
2439
2440 {
2441 b, err := cr.ReadByte()
2442 if err != nil {
2443 return err
2444 }
2445 if b != cbg.CborNull[0] {
2446 if err := cr.UnreadByte(); err != nil {
2447 return err
2448 }
2449
2450 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2451 if err != nil {
2452 return err
2453 }
2454
2455 t.Ref = (*string)(&sval)
2456 }
2457 }
2458 // t.Sha (string) (string)
2459 case "sha":
2460
2461 {
2462 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2463 if err != nil {
2464 return err
2465 }
2466
2467 t.Sha = string(sval)
2468 }
2469 // t.LexiconTypeID (string) (string)
2470 case "$type":
2471
2472 {
2473 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2474 if err != nil {
2475 return err
2476 }
2477
2478 t.LexiconTypeID = string(sval)
2479 }
2480 // t.Inputs ([]*tangled.CiTrigger_Pair) (slice)
2481 case "inputs":
2482
2483 maj, extra, err = cr.ReadHeader()
2484 if err != nil {
2485 return err
2486 }
2487
2488 if extra > 8192 {
2489 return fmt.Errorf("t.Inputs: array too large (%d)", extra)
2490 }
2491
2492 if maj != cbg.MajArray {
2493 return fmt.Errorf("expected cbor array")
2494 }
2495
2496 if extra > 0 {
2497 t.Inputs = make([]*CiTrigger_Pair, extra)
2498 }
2499
2500 for i := 0; i < int(extra); i++ {
2501 {
2502 var maj byte
2503 var extra uint64
2504 var err error
2505 _ = maj
2506 _ = extra
2507 _ = err
2508
2509 {
2510
2511 b, err := cr.ReadByte()
2512 if err != nil {
2513 return err
2514 }
2515 if b != cbg.CborNull[0] {
2516 if err := cr.UnreadByte(); err != nil {
2517 return err
2518 }
2519 t.Inputs[i] = new(CiTrigger_Pair)
2520 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
2521 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
2522 }
2523 }
2524
2525 }
2526
2527 }
2528 }
2529 // t.SourceRepo (string) (string)
2530 case "sourceRepo":
2531
2532 {
2533 b, err := cr.ReadByte()
2534 if err != nil {
2535 return err
2536 }
2537 if b != cbg.CborNull[0] {
2538 if err := cr.UnreadByte(); err != nil {
2539 return err
2540 }
2541
2542 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2543 if err != nil {
2544 return err
2545 }
2546
2547 t.SourceRepo = (*string)(&sval)
2548 }
2549 }
2550
2551 default:
2552 // Field doesn't exist on this type, so ignore it
2553 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2554 return err
2555 }
2556 }
2557 }
2558
2559 return nil
2560}
2561func (t *CiTrigger_Pair) MarshalCBOR(w io.Writer) error {
2562 if t == nil {
2563 _, err := w.Write(cbg.CborNull)
2564 return err
2565 }
2566
2567 cw := cbg.NewCborWriter(w)
2568
2569 if _, err := cw.Write([]byte{162}); err != nil {
2570 return err
2571 }
2572
2573 // t.Key (string) (string)
2574 if len("key") > 1000000 {
2575 return xerrors.Errorf("Value in field \"key\" was too long")
2576 }
2577
2578 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
2579 return err
2580 }
2581 if _, err := cw.WriteString(string("key")); err != nil {
2582 return err
2583 }
2584
2585 if len(t.Key) > 1000000 {
2586 return xerrors.Errorf("Value in field t.Key was too long")
2587 }
2588
2589 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
2590 return err
2591 }
2592 if _, err := cw.WriteString(string(t.Key)); err != nil {
2593 return err
2594 }
2595
2596 // t.Value (string) (string)
2597 if len("value") > 1000000 {
2598 return xerrors.Errorf("Value in field \"value\" was too long")
2599 }
2600
2601 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
2602 return err
2603 }
2604 if _, err := cw.WriteString(string("value")); err != nil {
2605 return err
2606 }
2607
2608 if len(t.Value) > 1000000 {
2609 return xerrors.Errorf("Value in field t.Value was too long")
2610 }
2611
2612 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
2613 return err
2614 }
2615 if _, err := cw.WriteString(string(t.Value)); err != nil {
2616 return err
2617 }
2618 return nil
2619}
2620
2621func (t *CiTrigger_Pair) UnmarshalCBOR(r io.Reader) (err error) {
2622 *t = CiTrigger_Pair{}
2623
2624 cr := cbg.NewCborReader(r)
2625
2626 maj, extra, err := cr.ReadHeader()
2627 if err != nil {
2628 return err
2629 }
2630 defer func() {
2631 if err == io.EOF {
2632 err = io.ErrUnexpectedEOF
2633 }
2634 }()
2635
2636 if maj != cbg.MajMap {
2637 return fmt.Errorf("cbor input should be of type map")
2638 }
2639
2640 if extra > cbg.MaxLength {
2641 return fmt.Errorf("CiTrigger_Pair: map struct too large (%d)", extra)
2642 }
2643
2644 n := extra
2645
2646 nameBuf := make([]byte, 5)
2647 for i := uint64(0); i < n; i++ {
2648 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2649 if err != nil {
2650 return err
2651 }
2652
2653 if !ok {
2654 // Field doesn't exist on this type, so ignore it
2655 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2656 return err
2657 }
2658 continue
2659 }
2660
2661 switch string(nameBuf[:nameLen]) {
2662 // t.Key (string) (string)
2663 case "key":
2664
2665 {
2666 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2667 if err != nil {
2668 return err
2669 }
2670
2671 t.Key = string(sval)
2672 }
2673 // t.Value (string) (string)
2674 case "value":
2675
2676 {
2677 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2678 if err != nil {
2679 return err
2680 }
2681
2682 t.Value = string(sval)
2683 }
2684
2685 default:
2686 // Field doesn't exist on this type, so ignore it
2687 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2688 return err
2689 }
2690 }
2691 }
2692
2693 return nil
2694}
2695func (t *CiTrigger_PullRequest) MarshalCBOR(w io.Writer) error {
2696 if t == nil {
2697 _, err := w.Write(cbg.CborNull)
2698 return err
2699 }
2700
2701 cw := cbg.NewCborWriter(w)
2702 fieldCount := 6
2703
2704 if t.Pull == nil {
2705 fieldCount--
2706 }
2707
2708 if t.SourceBranch == nil {
2709 fieldCount--
2710 }
2711
2712 if t.SourceRepo == nil {
2713 fieldCount--
2714 }
2715
2716 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2717 return err
2718 }
2719
2720 // t.Pull (string) (string)
2721 if t.Pull != nil {
2722
2723 if len("pull") > 1000000 {
2724 return xerrors.Errorf("Value in field \"pull\" was too long")
2725 }
2726
2727 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
2728 return err
2729 }
2730 if _, err := cw.WriteString(string("pull")); err != nil {
2731 return err
2732 }
2733
2734 if t.Pull == nil {
2735 if _, err := cw.Write(cbg.CborNull); err != nil {
2736 return err
2737 }
2738 } else {
2739 if len(*t.Pull) > 1000000 {
2740 return xerrors.Errorf("Value in field t.Pull was too long")
2741 }
2742
2743 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Pull))); err != nil {
2744 return err
2745 }
2746 if _, err := cw.WriteString(string(*t.Pull)); err != nil {
2747 return err
2748 }
2749 }
2750 }
2751
2752 // t.LexiconTypeID (string) (string)
2753 if len("$type") > 1000000 {
2754 return xerrors.Errorf("Value in field \"$type\" was too long")
2755 }
2756
2757 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2758 return err
2759 }
2760 if _, err := cw.WriteString(string("$type")); err != nil {
2761 return err
2762 }
2763
2764 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.ci.trigger#pullRequest"))); err != nil {
2765 return err
2766 }
2767 if _, err := cw.WriteString(string("sh.tangled.ci.trigger#pullRequest")); err != nil {
2768 return err
2769 }
2770
2771 // t.SourceSha (string) (string)
2772 if len("sourceSha") > 1000000 {
2773 return xerrors.Errorf("Value in field \"sourceSha\" was too long")
2774 }
2775
2776 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceSha"))); err != nil {
2777 return err
2778 }
2779 if _, err := cw.WriteString(string("sourceSha")); err != nil {
2780 return err
2781 }
2782
2783 if len(t.SourceSha) > 1000000 {
2784 return xerrors.Errorf("Value in field t.SourceSha was too long")
2785 }
2786
2787 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceSha))); err != nil {
2788 return err
2789 }
2790 if _, err := cw.WriteString(string(t.SourceSha)); err != nil {
2791 return err
2792 }
2793
2794 // t.SourceRepo (string) (string)
2795 if t.SourceRepo != nil {
2796
2797 if len("sourceRepo") > 1000000 {
2798 return xerrors.Errorf("Value in field \"sourceRepo\" was too long")
2799 }
2800
2801 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceRepo"))); err != nil {
2802 return err
2803 }
2804 if _, err := cw.WriteString(string("sourceRepo")); err != nil {
2805 return err
2806 }
2807
2808 if t.SourceRepo == nil {
2809 if _, err := cw.Write(cbg.CborNull); err != nil {
2810 return err
2811 }
2812 } else {
2813 if len(*t.SourceRepo) > 1000000 {
2814 return xerrors.Errorf("Value in field t.SourceRepo was too long")
2815 }
2816
2817 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.SourceRepo))); err != nil {
2818 return err
2819 }
2820 if _, err := cw.WriteString(string(*t.SourceRepo)); err != nil {
2821 return err
2822 }
2823 }
2824 }
2825
2826 // t.SourceBranch (string) (string)
2827 if t.SourceBranch != nil {
2828
2829 if len("sourceBranch") > 1000000 {
2830 return xerrors.Errorf("Value in field \"sourceBranch\" was too long")
2831 }
2832
2833 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceBranch"))); err != nil {
2834 return err
2835 }
2836 if _, err := cw.WriteString(string("sourceBranch")); err != nil {
2837 return err
2838 }
2839
2840 if t.SourceBranch == nil {
2841 if _, err := cw.Write(cbg.CborNull); err != nil {
2842 return err
2843 }
2844 } else {
2845 if len(*t.SourceBranch) > 1000000 {
2846 return xerrors.Errorf("Value in field t.SourceBranch was too long")
2847 }
2848
2849 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.SourceBranch))); err != nil {
2850 return err
2851 }
2852 if _, err := cw.WriteString(string(*t.SourceBranch)); err != nil {
2853 return err
2854 }
2855 }
2856 }
2857
2858 // t.TargetBranch (string) (string)
2859 if len("targetBranch") > 1000000 {
2860 return xerrors.Errorf("Value in field \"targetBranch\" was too long")
2861 }
2862
2863 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil {
2864 return err
2865 }
2866 if _, err := cw.WriteString(string("targetBranch")); err != nil {
2867 return err
2868 }
2869
2870 if len(t.TargetBranch) > 1000000 {
2871 return xerrors.Errorf("Value in field t.TargetBranch was too long")
2872 }
2873
2874 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil {
2875 return err
2876 }
2877 if _, err := cw.WriteString(string(t.TargetBranch)); err != nil {
2878 return err
2879 }
2880 return nil
2881}
2882
2883func (t *CiTrigger_PullRequest) UnmarshalCBOR(r io.Reader) (err error) {
2884 *t = CiTrigger_PullRequest{}
2885
2886 cr := cbg.NewCborReader(r)
2887
2888 maj, extra, err := cr.ReadHeader()
2889 if err != nil {
2890 return err
2891 }
2892 defer func() {
2893 if err == io.EOF {
2894 err = io.ErrUnexpectedEOF
2895 }
2896 }()
2897
2898 if maj != cbg.MajMap {
2899 return fmt.Errorf("cbor input should be of type map")
2900 }
2901
2902 if extra > cbg.MaxLength {
2903 return fmt.Errorf("CiTrigger_PullRequest: map struct too large (%d)", extra)
2904 }
2905
2906 n := extra
2907
2908 nameBuf := make([]byte, 12)
2909 for i := uint64(0); i < n; i++ {
2910 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2911 if err != nil {
2912 return err
2913 }
2914
2915 if !ok {
2916 // Field doesn't exist on this type, so ignore it
2917 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2918 return err
2919 }
2920 continue
2921 }
2922
2923 switch string(nameBuf[:nameLen]) {
2924 // t.Pull (string) (string)
2925 case "pull":
2926
2927 {
2928 b, err := cr.ReadByte()
2929 if err != nil {
2930 return err
2931 }
2932 if b != cbg.CborNull[0] {
2933 if err := cr.UnreadByte(); err != nil {
2934 return err
2935 }
2936
2937 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2938 if err != nil {
2939 return err
2940 }
2941
2942 t.Pull = (*string)(&sval)
2943 }
2944 }
2945 // t.LexiconTypeID (string) (string)
2946 case "$type":
2947
2948 {
2949 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2950 if err != nil {
2951 return err
2952 }
2953
2954 t.LexiconTypeID = string(sval)
2955 }
2956 // t.SourceSha (string) (string)
2957 case "sourceSha":
2958
2959 {
2960 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2961 if err != nil {
2962 return err
2963 }
2964
2965 t.SourceSha = string(sval)
2966 }
2967 // t.SourceRepo (string) (string)
2968 case "sourceRepo":
2969
2970 {
2971 b, err := cr.ReadByte()
2972 if err != nil {
2973 return err
2974 }
2975 if b != cbg.CborNull[0] {
2976 if err := cr.UnreadByte(); err != nil {
2977 return err
2978 }
2979
2980 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2981 if err != nil {
2982 return err
2983 }
2984
2985 t.SourceRepo = (*string)(&sval)
2986 }
2987 }
2988 // t.SourceBranch (string) (string)
2989 case "sourceBranch":
2990
2991 {
2992 b, err := cr.ReadByte()
2993 if err != nil {
2994 return err
2995 }
2996 if b != cbg.CborNull[0] {
2997 if err := cr.UnreadByte(); err != nil {
2998 return err
2999 }
3000
3001 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3002 if err != nil {
3003 return err
3004 }
3005
3006 t.SourceBranch = (*string)(&sval)
3007 }
3008 }
3009 // t.TargetBranch (string) (string)
3010 case "targetBranch":
3011
3012 {
3013 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3014 if err != nil {
3015 return err
3016 }
3017
3018 t.TargetBranch = string(sval)
3019 }
3020
3021 default:
3022 // Field doesn't exist on this type, so ignore it
3023 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3024 return err
3025 }
3026 }
3027 }
3028
3029 return nil
3030}
3031func (t *CiTrigger_Push) MarshalCBOR(w io.Writer) error {
3032 if t == nil {
3033 _, err := w.Write(cbg.CborNull)
3034 return err
3035 }
3036
3037 cw := cbg.NewCborWriter(w)
3038
3039 if _, err := cw.Write([]byte{164}); err != nil {
3040 return err
3041 }
3042
3043 // t.Ref (string) (string)
3044 if len("ref") > 1000000 {
3045 return xerrors.Errorf("Value in field \"ref\" was too long")
3046 }
3047
3048 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
3049 return err
3050 }
3051 if _, err := cw.WriteString(string("ref")); err != nil {
3052 return err
3053 }
3054
3055 if len(t.Ref) > 1000000 {
3056 return xerrors.Errorf("Value in field t.Ref was too long")
3057 }
3058
3059 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
3060 return err
3061 }
3062 if _, err := cw.WriteString(string(t.Ref)); err != nil {
3063 return err
3064 }
3065
3066 // t.LexiconTypeID (string) (string)
3067 if len("$type") > 1000000 {
3068 return xerrors.Errorf("Value in field \"$type\" was too long")
3069 }
3070
3071 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3072 return err
3073 }
3074 if _, err := cw.WriteString(string("$type")); err != nil {
3075 return err
3076 }
3077
3078 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.ci.trigger#push"))); err != nil {
3079 return err
3080 }
3081 if _, err := cw.WriteString(string("sh.tangled.ci.trigger#push")); err != nil {
3082 return err
3083 }
3084
3085 // t.NewSha (string) (string)
3086 if len("newSha") > 1000000 {
3087 return xerrors.Errorf("Value in field \"newSha\" was too long")
3088 }
3089
3090 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
3091 return err
3092 }
3093 if _, err := cw.WriteString(string("newSha")); err != nil {
3094 return err
3095 }
3096
3097 if len(t.NewSha) > 1000000 {
3098 return xerrors.Errorf("Value in field t.NewSha was too long")
3099 }
3100
3101 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
3102 return err
3103 }
3104 if _, err := cw.WriteString(string(t.NewSha)); err != nil {
3105 return err
3106 }
3107
3108 // t.OldSha (string) (string)
3109 if len("oldSha") > 1000000 {
3110 return xerrors.Errorf("Value in field \"oldSha\" was too long")
3111 }
3112
3113 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
3114 return err
3115 }
3116 if _, err := cw.WriteString(string("oldSha")); err != nil {
3117 return err
3118 }
3119
3120 if len(t.OldSha) > 1000000 {
3121 return xerrors.Errorf("Value in field t.OldSha was too long")
3122 }
3123
3124 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
3125 return err
3126 }
3127 if _, err := cw.WriteString(string(t.OldSha)); err != nil {
3128 return err
3129 }
3130 return nil
3131}
3132
3133func (t *CiTrigger_Push) UnmarshalCBOR(r io.Reader) (err error) {
3134 *t = CiTrigger_Push{}
3135
3136 cr := cbg.NewCborReader(r)
3137
3138 maj, extra, err := cr.ReadHeader()
3139 if err != nil {
3140 return err
3141 }
3142 defer func() {
3143 if err == io.EOF {
3144 err = io.ErrUnexpectedEOF
3145 }
3146 }()
3147
3148 if maj != cbg.MajMap {
3149 return fmt.Errorf("cbor input should be of type map")
3150 }
3151
3152 if extra > cbg.MaxLength {
3153 return fmt.Errorf("CiTrigger_Push: map struct too large (%d)", extra)
3154 }
3155
3156 n := extra
3157
3158 nameBuf := make([]byte, 6)
3159 for i := uint64(0); i < n; i++ {
3160 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3161 if err != nil {
3162 return err
3163 }
3164
3165 if !ok {
3166 // Field doesn't exist on this type, so ignore it
3167 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3168 return err
3169 }
3170 continue
3171 }
3172
3173 switch string(nameBuf[:nameLen]) {
3174 // t.Ref (string) (string)
3175 case "ref":
3176
3177 {
3178 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3179 if err != nil {
3180 return err
3181 }
3182
3183 t.Ref = string(sval)
3184 }
3185 // t.LexiconTypeID (string) (string)
3186 case "$type":
3187
3188 {
3189 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3190 if err != nil {
3191 return err
3192 }
3193
3194 t.LexiconTypeID = string(sval)
3195 }
3196 // t.NewSha (string) (string)
3197 case "newSha":
3198
3199 {
3200 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3201 if err != nil {
3202 return err
3203 }
3204
3205 t.NewSha = string(sval)
3206 }
3207 // t.OldSha (string) (string)
3208 case "oldSha":
3209
3210 {
3211 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3212 if err != nil {
3213 return err
3214 }
3215
3216 t.OldSha = string(sval)
3217 }
3218
3219 default:
3220 // Field doesn't exist on this type, so ignore it
3221 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3222 return err
3223 }
3224 }
3225 }
3226
3227 return nil
3228}
3229func (t *FeedComment) MarshalCBOR(w io.Writer) error {
3230 if t == nil {
3231 _, err := w.Write(cbg.CborNull)
3232 return err
3233 }
3234
3235 cw := cbg.NewCborWriter(w)
3236 fieldCount := 6
3237
3238 if t.PullRoundIdx == nil {
3239 fieldCount--
3240 }
3241
3242 if t.ReplyTo == nil {
3243 fieldCount--
3244 }
3245
3246 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3247 return err
3248 }
3249
3250 // t.Body (tangled.FeedComment_Body) (struct)
3251 if len("body") > 1000000 {
3252 return xerrors.Errorf("Value in field \"body\" was too long")
3253 }
3254
3255 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
3256 return err
3257 }
3258 if _, err := cw.WriteString(string("body")); err != nil {
3259 return err
3260 }
3261
3262 if err := t.Body.MarshalCBOR(cw); err != nil {
3263 return err
3264 }
3265
3266 // t.LexiconTypeID (string) (string)
3267 if len("$type") > 1000000 {
3268 return xerrors.Errorf("Value in field \"$type\" was too long")
3269 }
3270
3271 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3272 return err
3273 }
3274 if _, err := cw.WriteString(string("$type")); err != nil {
3275 return err
3276 }
3277
3278 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.comment"))); err != nil {
3279 return err
3280 }
3281 if _, err := cw.WriteString(string("sh.tangled.feed.comment")); err != nil {
3282 return err
3283 }
3284
3285 // t.ReplyTo (atproto.RepoStrongRef) (struct)
3286 if t.ReplyTo != nil {
3287
3288 if len("replyTo") > 1000000 {
3289 return xerrors.Errorf("Value in field \"replyTo\" was too long")
3290 }
3291
3292 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("replyTo"))); err != nil {
3293 return err
3294 }
3295 if _, err := cw.WriteString(string("replyTo")); err != nil {
3296 return err
3297 }
3298
3299 if err := t.ReplyTo.MarshalCBOR(cw); err != nil {
3300 return err
3301 }
3302 }
3303
3304 // t.Subject (atproto.RepoStrongRef) (struct)
3305 if len("subject") > 1000000 {
3306 return xerrors.Errorf("Value in field \"subject\" was too long")
3307 }
3308
3309 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
3310 return err
3311 }
3312 if _, err := cw.WriteString(string("subject")); err != nil {
3313 return err
3314 }
3315
3316 if err := t.Subject.MarshalCBOR(cw); err != nil {
3317 return err
3318 }
3319
3320 // t.CreatedAt (string) (string)
3321 if len("createdAt") > 1000000 {
3322 return xerrors.Errorf("Value in field \"createdAt\" was too long")
3323 }
3324
3325 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
3326 return err
3327 }
3328 if _, err := cw.WriteString(string("createdAt")); err != nil {
3329 return err
3330 }
3331
3332 if len(t.CreatedAt) > 1000000 {
3333 return xerrors.Errorf("Value in field t.CreatedAt was too long")
3334 }
3335
3336 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
3337 return err
3338 }
3339 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
3340 return err
3341 }
3342
3343 // t.PullRoundIdx (int64) (int64)
3344 if t.PullRoundIdx != nil {
3345
3346 if len("pullRoundIdx") > 1000000 {
3347 return xerrors.Errorf("Value in field \"pullRoundIdx\" was too long")
3348 }
3349
3350 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullRoundIdx"))); err != nil {
3351 return err
3352 }
3353 if _, err := cw.WriteString(string("pullRoundIdx")); err != nil {
3354 return err
3355 }
3356
3357 if t.PullRoundIdx == nil {
3358 if _, err := cw.Write(cbg.CborNull); err != nil {
3359 return err
3360 }
3361 } else {
3362 if *t.PullRoundIdx >= 0 {
3363 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.PullRoundIdx)); err != nil {
3364 return err
3365 }
3366 } else {
3367 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.PullRoundIdx-1)); err != nil {
3368 return err
3369 }
3370 }
3371 }
3372
3373 }
3374 return nil
3375}
3376
3377func (t *FeedComment) UnmarshalCBOR(r io.Reader) (err error) {
3378 *t = FeedComment{}
3379
3380 cr := cbg.NewCborReader(r)
3381
3382 maj, extra, err := cr.ReadHeader()
3383 if err != nil {
3384 return err
3385 }
3386 defer func() {
3387 if err == io.EOF {
3388 err = io.ErrUnexpectedEOF
3389 }
3390 }()
3391
3392 if maj != cbg.MajMap {
3393 return fmt.Errorf("cbor input should be of type map")
3394 }
3395
3396 if extra > cbg.MaxLength {
3397 return fmt.Errorf("FeedComment: map struct too large (%d)", extra)
3398 }
3399
3400 n := extra
3401
3402 nameBuf := make([]byte, 12)
3403 for i := uint64(0); i < n; i++ {
3404 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3405 if err != nil {
3406 return err
3407 }
3408
3409 if !ok {
3410 // Field doesn't exist on this type, so ignore it
3411 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3412 return err
3413 }
3414 continue
3415 }
3416
3417 switch string(nameBuf[:nameLen]) {
3418 // t.Body (tangled.FeedComment_Body) (struct)
3419 case "body":
3420
3421 {
3422
3423 b, err := cr.ReadByte()
3424 if err != nil {
3425 return err
3426 }
3427 if b != cbg.CborNull[0] {
3428 if err := cr.UnreadByte(); err != nil {
3429 return err
3430 }
3431 t.Body = new(FeedComment_Body)
3432 if err := t.Body.UnmarshalCBOR(cr); err != nil {
3433 return xerrors.Errorf("unmarshaling t.Body pointer: %w", err)
3434 }
3435 }
3436
3437 }
3438 // t.LexiconTypeID (string) (string)
3439 case "$type":
3440
3441 {
3442 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3443 if err != nil {
3444 return err
3445 }
3446
3447 t.LexiconTypeID = string(sval)
3448 }
3449 // t.ReplyTo (atproto.RepoStrongRef) (struct)
3450 case "replyTo":
3451
3452 {
3453
3454 b, err := cr.ReadByte()
3455 if err != nil {
3456 return err
3457 }
3458 if b != cbg.CborNull[0] {
3459 if err := cr.UnreadByte(); err != nil {
3460 return err
3461 }
3462 t.ReplyTo = new(atproto.RepoStrongRef)
3463 if err := t.ReplyTo.UnmarshalCBOR(cr); err != nil {
3464 return xerrors.Errorf("unmarshaling t.ReplyTo pointer: %w", err)
3465 }
3466 }
3467
3468 }
3469 // t.Subject (atproto.RepoStrongRef) (struct)
3470 case "subject":
3471
3472 {
3473
3474 b, err := cr.ReadByte()
3475 if err != nil {
3476 return err
3477 }
3478 if b != cbg.CborNull[0] {
3479 if err := cr.UnreadByte(); err != nil {
3480 return err
3481 }
3482 t.Subject = new(atproto.RepoStrongRef)
3483 if err := t.Subject.UnmarshalCBOR(cr); err != nil {
3484 return xerrors.Errorf("unmarshaling t.Subject pointer: %w", err)
3485 }
3486 }
3487
3488 }
3489 // t.CreatedAt (string) (string)
3490 case "createdAt":
3491
3492 {
3493 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3494 if err != nil {
3495 return err
3496 }
3497
3498 t.CreatedAt = string(sval)
3499 }
3500 // t.PullRoundIdx (int64) (int64)
3501 case "pullRoundIdx":
3502 {
3503
3504 b, err := cr.ReadByte()
3505 if err != nil {
3506 return err
3507 }
3508 if b != cbg.CborNull[0] {
3509 if err := cr.UnreadByte(); err != nil {
3510 return err
3511 }
3512 maj, extra, err := cr.ReadHeader()
3513 if err != nil {
3514 return err
3515 }
3516 var extraI int64
3517 switch maj {
3518 case cbg.MajUnsignedInt:
3519 extraI = int64(extra)
3520 if extraI < 0 {
3521 return fmt.Errorf("int64 positive overflow")
3522 }
3523 case cbg.MajNegativeInt:
3524 extraI = int64(extra)
3525 if extraI < 0 {
3526 return fmt.Errorf("int64 negative overflow")
3527 }
3528 extraI = -1 - extraI
3529 default:
3530 return fmt.Errorf("wrong type for int64 field: %d", maj)
3531 }
3532
3533 t.PullRoundIdx = (*int64)(&extraI)
3534 }
3535 }
3536
3537 default:
3538 // Field doesn't exist on this type, so ignore it
3539 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3540 return err
3541 }
3542 }
3543 }
3544
3545 return nil
3546}
3547func (t *FeedReaction) MarshalCBOR(w io.Writer) error {
3548 if t == nil {
3549 _, err := w.Write(cbg.CborNull)
3550 return err
3551 }
3552
3553 cw := cbg.NewCborWriter(w)
3554
3555 if _, err := cw.Write([]byte{164}); err != nil {
3556 return err
3557 }
3558
3559 // t.LexiconTypeID (string) (string)
3560 if len("$type") > 1000000 {
3561 return xerrors.Errorf("Value in field \"$type\" was too long")
3562 }
3563
3564 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3565 return err
3566 }
3567 if _, err := cw.WriteString(string("$type")); err != nil {
3568 return err
3569 }
3570
3571 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.reaction"))); err != nil {
3572 return err
3573 }
3574 if _, err := cw.WriteString(string("sh.tangled.feed.reaction")); err != nil {
3575 return err
3576 }
3577
3578 // t.Subject (string) (string)
3579 if len("subject") > 1000000 {
3580 return xerrors.Errorf("Value in field \"subject\" was too long")
3581 }
3582
3583 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
3584 return err
3585 }
3586 if _, err := cw.WriteString(string("subject")); err != nil {
3587 return err
3588 }
3589
3590 if len(t.Subject) > 1000000 {
3591 return xerrors.Errorf("Value in field t.Subject was too long")
3592 }
3593
3594 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
3595 return err
3596 }
3597 if _, err := cw.WriteString(string(t.Subject)); err != nil {
3598 return err
3599 }
3600
3601 // t.Reaction (string) (string)
3602 if len("reaction") > 1000000 {
3603 return xerrors.Errorf("Value in field \"reaction\" was too long")
3604 }
3605
3606 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("reaction"))); err != nil {
3607 return err
3608 }
3609 if _, err := cw.WriteString(string("reaction")); err != nil {
3610 return err
3611 }
3612
3613 if len(t.Reaction) > 1000000 {
3614 return xerrors.Errorf("Value in field t.Reaction was too long")
3615 }
3616
3617 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Reaction))); err != nil {
3618 return err
3619 }
3620 if _, err := cw.WriteString(string(t.Reaction)); err != nil {
3621 return err
3622 }
3623
3624 // t.CreatedAt (string) (string)
3625 if len("createdAt") > 1000000 {
3626 return xerrors.Errorf("Value in field \"createdAt\" was too long")
3627 }
3628
3629 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
3630 return err
3631 }
3632 if _, err := cw.WriteString(string("createdAt")); err != nil {
3633 return err
3634 }
3635
3636 if len(t.CreatedAt) > 1000000 {
3637 return xerrors.Errorf("Value in field t.CreatedAt was too long")
3638 }
3639
3640 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
3641 return err
3642 }
3643 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
3644 return err
3645 }
3646 return nil
3647}
3648
3649func (t *FeedReaction) UnmarshalCBOR(r io.Reader) (err error) {
3650 *t = FeedReaction{}
3651
3652 cr := cbg.NewCborReader(r)
3653
3654 maj, extra, err := cr.ReadHeader()
3655 if err != nil {
3656 return err
3657 }
3658 defer func() {
3659 if err == io.EOF {
3660 err = io.ErrUnexpectedEOF
3661 }
3662 }()
3663
3664 if maj != cbg.MajMap {
3665 return fmt.Errorf("cbor input should be of type map")
3666 }
3667
3668 if extra > cbg.MaxLength {
3669 return fmt.Errorf("FeedReaction: map struct too large (%d)", extra)
3670 }
3671
3672 n := extra
3673
3674 nameBuf := make([]byte, 9)
3675 for i := uint64(0); i < n; i++ {
3676 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3677 if err != nil {
3678 return err
3679 }
3680
3681 if !ok {
3682 // Field doesn't exist on this type, so ignore it
3683 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3684 return err
3685 }
3686 continue
3687 }
3688
3689 switch string(nameBuf[:nameLen]) {
3690 // t.LexiconTypeID (string) (string)
3691 case "$type":
3692
3693 {
3694 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3695 if err != nil {
3696 return err
3697 }
3698
3699 t.LexiconTypeID = string(sval)
3700 }
3701 // t.Subject (string) (string)
3702 case "subject":
3703
3704 {
3705 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3706 if err != nil {
3707 return err
3708 }
3709
3710 t.Subject = string(sval)
3711 }
3712 // t.Reaction (string) (string)
3713 case "reaction":
3714
3715 {
3716 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3717 if err != nil {
3718 return err
3719 }
3720
3721 t.Reaction = string(sval)
3722 }
3723 // t.CreatedAt (string) (string)
3724 case "createdAt":
3725
3726 {
3727 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3728 if err != nil {
3729 return err
3730 }
3731
3732 t.CreatedAt = string(sval)
3733 }
3734
3735 default:
3736 // Field doesn't exist on this type, so ignore it
3737 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3738 return err
3739 }
3740 }
3741 }
3742
3743 return nil
3744}
3745func (t *FeedStar) MarshalCBOR(w io.Writer) error {
3746 if t == nil {
3747 _, err := w.Write(cbg.CborNull)
3748 return err
3749 }
3750
3751 cw := cbg.NewCborWriter(w)
3752
3753 if _, err := cw.Write([]byte{163}); err != nil {
3754 return err
3755 }
3756
3757 // t.LexiconTypeID (string) (string)
3758 if len("$type") > 1000000 {
3759 return xerrors.Errorf("Value in field \"$type\" was too long")
3760 }
3761
3762 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3763 return err
3764 }
3765 if _, err := cw.WriteString(string("$type")); err != nil {
3766 return err
3767 }
3768
3769 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.star"))); err != nil {
3770 return err
3771 }
3772 if _, err := cw.WriteString(string("sh.tangled.feed.star")); err != nil {
3773 return err
3774 }
3775
3776 // t.Subject (tangled.FeedStar_Subject) (struct)
3777 if len("subject") > 1000000 {
3778 return xerrors.Errorf("Value in field \"subject\" was too long")
3779 }
3780
3781 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
3782 return err
3783 }
3784 if _, err := cw.WriteString(string("subject")); err != nil {
3785 return err
3786 }
3787
3788 if err := t.Subject.MarshalCBOR(cw); err != nil {
3789 return err
3790 }
3791
3792 // t.CreatedAt (string) (string)
3793 if len("createdAt") > 1000000 {
3794 return xerrors.Errorf("Value in field \"createdAt\" was too long")
3795 }
3796
3797 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
3798 return err
3799 }
3800 if _, err := cw.WriteString(string("createdAt")); err != nil {
3801 return err
3802 }
3803
3804 if len(t.CreatedAt) > 1000000 {
3805 return xerrors.Errorf("Value in field t.CreatedAt was too long")
3806 }
3807
3808 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
3809 return err
3810 }
3811 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
3812 return err
3813 }
3814 return nil
3815}
3816
3817func (t *FeedStar) UnmarshalCBOR(r io.Reader) (err error) {
3818 *t = FeedStar{}
3819
3820 cr := cbg.NewCborReader(r)
3821
3822 maj, extra, err := cr.ReadHeader()
3823 if err != nil {
3824 return err
3825 }
3826 defer func() {
3827 if err == io.EOF {
3828 err = io.ErrUnexpectedEOF
3829 }
3830 }()
3831
3832 if maj != cbg.MajMap {
3833 return fmt.Errorf("cbor input should be of type map")
3834 }
3835
3836 if extra > cbg.MaxLength {
3837 return fmt.Errorf("FeedStar: map struct too large (%d)", extra)
3838 }
3839
3840 n := extra
3841
3842 nameBuf := make([]byte, 9)
3843 for i := uint64(0); i < n; i++ {
3844 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3845 if err != nil {
3846 return err
3847 }
3848
3849 if !ok {
3850 // Field doesn't exist on this type, so ignore it
3851 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3852 return err
3853 }
3854 continue
3855 }
3856
3857 switch string(nameBuf[:nameLen]) {
3858 // t.LexiconTypeID (string) (string)
3859 case "$type":
3860
3861 {
3862 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3863 if err != nil {
3864 return err
3865 }
3866
3867 t.LexiconTypeID = string(sval)
3868 }
3869 // t.Subject (tangled.FeedStar_Subject) (struct)
3870 case "subject":
3871
3872 {
3873
3874 b, err := cr.ReadByte()
3875 if err != nil {
3876 return err
3877 }
3878 if b != cbg.CborNull[0] {
3879 if err := cr.UnreadByte(); err != nil {
3880 return err
3881 }
3882 t.Subject = new(FeedStar_Subject)
3883 if err := t.Subject.UnmarshalCBOR(cr); err != nil {
3884 return xerrors.Errorf("unmarshaling t.Subject pointer: %w", err)
3885 }
3886 }
3887
3888 }
3889 // t.CreatedAt (string) (string)
3890 case "createdAt":
3891
3892 {
3893 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3894 if err != nil {
3895 return err
3896 }
3897
3898 t.CreatedAt = string(sval)
3899 }
3900
3901 default:
3902 // Field doesn't exist on this type, so ignore it
3903 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3904 return err
3905 }
3906 }
3907 }
3908
3909 return nil
3910}
3911func (t *FeedStar_Repo) MarshalCBOR(w io.Writer) error {
3912 if t == nil {
3913 _, err := w.Write(cbg.CborNull)
3914 return err
3915 }
3916
3917 cw := cbg.NewCborWriter(w)
3918
3919 if _, err := cw.Write([]byte{162}); err != nil {
3920 return err
3921 }
3922
3923 // t.Did (string) (string)
3924 if len("did") > 1000000 {
3925 return xerrors.Errorf("Value in field \"did\" was too long")
3926 }
3927
3928 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil {
3929 return err
3930 }
3931 if _, err := cw.WriteString(string("did")); err != nil {
3932 return err
3933 }
3934
3935 if len(t.Did) > 1000000 {
3936 return xerrors.Errorf("Value in field t.Did was too long")
3937 }
3938
3939 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil {
3940 return err
3941 }
3942 if _, err := cw.WriteString(string(t.Did)); err != nil {
3943 return err
3944 }
3945
3946 // t.LexiconTypeID (string) (string)
3947 if len("$type") > 1000000 {
3948 return xerrors.Errorf("Value in field \"$type\" was too long")
3949 }
3950
3951 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3952 return err
3953 }
3954 if _, err := cw.WriteString(string("$type")); err != nil {
3955 return err
3956 }
3957
3958 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.star#repo"))); err != nil {
3959 return err
3960 }
3961 if _, err := cw.WriteString(string("sh.tangled.feed.star#repo")); err != nil {
3962 return err
3963 }
3964 return nil
3965}
3966
3967func (t *FeedStar_Repo) UnmarshalCBOR(r io.Reader) (err error) {
3968 *t = FeedStar_Repo{}
3969
3970 cr := cbg.NewCborReader(r)
3971
3972 maj, extra, err := cr.ReadHeader()
3973 if err != nil {
3974 return err
3975 }
3976 defer func() {
3977 if err == io.EOF {
3978 err = io.ErrUnexpectedEOF
3979 }
3980 }()
3981
3982 if maj != cbg.MajMap {
3983 return fmt.Errorf("cbor input should be of type map")
3984 }
3985
3986 if extra > cbg.MaxLength {
3987 return fmt.Errorf("FeedStar_Repo: map struct too large (%d)", extra)
3988 }
3989
3990 n := extra
3991
3992 nameBuf := make([]byte, 5)
3993 for i := uint64(0); i < n; i++ {
3994 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3995 if err != nil {
3996 return err
3997 }
3998
3999 if !ok {
4000 // Field doesn't exist on this type, so ignore it
4001 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4002 return err
4003 }
4004 continue
4005 }
4006
4007 switch string(nameBuf[:nameLen]) {
4008 // t.Did (string) (string)
4009 case "did":
4010
4011 {
4012 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4013 if err != nil {
4014 return err
4015 }
4016
4017 t.Did = string(sval)
4018 }
4019 // t.LexiconTypeID (string) (string)
4020 case "$type":
4021
4022 {
4023 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4024 if err != nil {
4025 return err
4026 }
4027
4028 t.LexiconTypeID = string(sval)
4029 }
4030
4031 default:
4032 // Field doesn't exist on this type, so ignore it
4033 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4034 return err
4035 }
4036 }
4037 }
4038
4039 return nil
4040}
4041func (t *FeedStar_String) MarshalCBOR(w io.Writer) error {
4042 if t == nil {
4043 _, err := w.Write(cbg.CborNull)
4044 return err
4045 }
4046
4047 cw := cbg.NewCborWriter(w)
4048
4049 if _, err := cw.Write([]byte{162}); err != nil {
4050 return err
4051 }
4052
4053 // t.Uri (string) (string)
4054 if len("uri") > 1000000 {
4055 return xerrors.Errorf("Value in field \"uri\" was too long")
4056 }
4057
4058 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("uri"))); err != nil {
4059 return err
4060 }
4061 if _, err := cw.WriteString(string("uri")); err != nil {
4062 return err
4063 }
4064
4065 if len(t.Uri) > 1000000 {
4066 return xerrors.Errorf("Value in field t.Uri was too long")
4067 }
4068
4069 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Uri))); err != nil {
4070 return err
4071 }
4072 if _, err := cw.WriteString(string(t.Uri)); err != nil {
4073 return err
4074 }
4075
4076 // t.LexiconTypeID (string) (string)
4077 if len("$type") > 1000000 {
4078 return xerrors.Errorf("Value in field \"$type\" was too long")
4079 }
4080
4081 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
4082 return err
4083 }
4084 if _, err := cw.WriteString(string("$type")); err != nil {
4085 return err
4086 }
4087
4088 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.star#string"))); err != nil {
4089 return err
4090 }
4091 if _, err := cw.WriteString(string("sh.tangled.feed.star#string")); err != nil {
4092 return err
4093 }
4094 return nil
4095}
4096
4097func (t *FeedStar_String) UnmarshalCBOR(r io.Reader) (err error) {
4098 *t = FeedStar_String{}
4099
4100 cr := cbg.NewCborReader(r)
4101
4102 maj, extra, err := cr.ReadHeader()
4103 if err != nil {
4104 return err
4105 }
4106 defer func() {
4107 if err == io.EOF {
4108 err = io.ErrUnexpectedEOF
4109 }
4110 }()
4111
4112 if maj != cbg.MajMap {
4113 return fmt.Errorf("cbor input should be of type map")
4114 }
4115
4116 if extra > cbg.MaxLength {
4117 return fmt.Errorf("FeedStar_String: map struct too large (%d)", extra)
4118 }
4119
4120 n := extra
4121
4122 nameBuf := make([]byte, 5)
4123 for i := uint64(0); i < n; i++ {
4124 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4125 if err != nil {
4126 return err
4127 }
4128
4129 if !ok {
4130 // Field doesn't exist on this type, so ignore it
4131 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4132 return err
4133 }
4134 continue
4135 }
4136
4137 switch string(nameBuf[:nameLen]) {
4138 // t.Uri (string) (string)
4139 case "uri":
4140
4141 {
4142 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4143 if err != nil {
4144 return err
4145 }
4146
4147 t.Uri = string(sval)
4148 }
4149 // t.LexiconTypeID (string) (string)
4150 case "$type":
4151
4152 {
4153 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4154 if err != nil {
4155 return err
4156 }
4157
4158 t.LexiconTypeID = string(sval)
4159 }
4160
4161 default:
4162 // Field doesn't exist on this type, so ignore it
4163 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4164 return err
4165 }
4166 }
4167 }
4168
4169 return nil
4170}
4171func (t *GitRefUpdate) MarshalCBOR(w io.Writer) error {
4172 if t == nil {
4173 _, err := w.Write(cbg.CborNull)
4174 return err
4175 }
4176
4177 cw := cbg.NewCborWriter(w)
4178 fieldCount := 10
4179
4180 if t.ChangedFiles == nil {
4181 fieldCount--
4182 }
4183
4184 if t.OwnerDid == nil {
4185 fieldCount--
4186 }
4187
4188 if t.PushOptions == nil {
4189 fieldCount--
4190 }
4191
4192 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4193 return err
4194 }
4195
4196 // t.Ref (string) (string)
4197 if len("ref") > 1000000 {
4198 return xerrors.Errorf("Value in field \"ref\" was too long")
4199 }
4200
4201 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
4202 return err
4203 }
4204 if _, err := cw.WriteString(string("ref")); err != nil {
4205 return err
4206 }
4207
4208 if len(t.Ref) > 1000000 {
4209 return xerrors.Errorf("Value in field t.Ref was too long")
4210 }
4211
4212 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
4213 return err
4214 }
4215 if _, err := cw.WriteString(string(t.Ref)); err != nil {
4216 return err
4217 }
4218
4219 // t.Meta (tangled.GitRefUpdate_Meta) (struct)
4220 if len("meta") > 1000000 {
4221 return xerrors.Errorf("Value in field \"meta\" was too long")
4222 }
4223
4224 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil {
4225 return err
4226 }
4227 if _, err := cw.WriteString(string("meta")); err != nil {
4228 return err
4229 }
4230
4231 if err := t.Meta.MarshalCBOR(cw); err != nil {
4232 return err
4233 }
4234
4235 // t.Repo (string) (string)
4236 if len("repo") > 1000000 {
4237 return xerrors.Errorf("Value in field \"repo\" was too long")
4238 }
4239
4240 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
4241 return err
4242 }
4243 if _, err := cw.WriteString(string("repo")); err != nil {
4244 return err
4245 }
4246
4247 if len(t.Repo) > 1000000 {
4248 return xerrors.Errorf("Value in field t.Repo was too long")
4249 }
4250
4251 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
4252 return err
4253 }
4254 if _, err := cw.WriteString(string(t.Repo)); err != nil {
4255 return err
4256 }
4257
4258 // t.LexiconTypeID (string) (string)
4259 if len("$type") > 1000000 {
4260 return xerrors.Errorf("Value in field \"$type\" was too long")
4261 }
4262
4263 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
4264 return err
4265 }
4266 if _, err := cw.WriteString(string("$type")); err != nil {
4267 return err
4268 }
4269
4270 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.git.refUpdate"))); err != nil {
4271 return err
4272 }
4273 if _, err := cw.WriteString(string("sh.tangled.git.refUpdate")); err != nil {
4274 return err
4275 }
4276
4277 // t.NewSha (string) (string)
4278 if len("newSha") > 1000000 {
4279 return xerrors.Errorf("Value in field \"newSha\" was too long")
4280 }
4281
4282 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
4283 return err
4284 }
4285 if _, err := cw.WriteString(string("newSha")); err != nil {
4286 return err
4287 }
4288
4289 if len(t.NewSha) > 1000000 {
4290 return xerrors.Errorf("Value in field t.NewSha was too long")
4291 }
4292
4293 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
4294 return err
4295 }
4296 if _, err := cw.WriteString(string(t.NewSha)); err != nil {
4297 return err
4298 }
4299
4300 // t.OldSha (string) (string)
4301 if len("oldSha") > 1000000 {
4302 return xerrors.Errorf("Value in field \"oldSha\" was too long")
4303 }
4304
4305 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
4306 return err
4307 }
4308 if _, err := cw.WriteString(string("oldSha")); err != nil {
4309 return err
4310 }
4311
4312 if len(t.OldSha) > 1000000 {
4313 return xerrors.Errorf("Value in field t.OldSha was too long")
4314 }
4315
4316 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
4317 return err
4318 }
4319 if _, err := cw.WriteString(string(t.OldSha)); err != nil {
4320 return err
4321 }
4322
4323 // t.OwnerDid (string) (string)
4324 if t.OwnerDid != nil {
4325
4326 if len("ownerDid") > 1000000 {
4327 return xerrors.Errorf("Value in field \"ownerDid\" was too long")
4328 }
4329
4330 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ownerDid"))); err != nil {
4331 return err
4332 }
4333 if _, err := cw.WriteString(string("ownerDid")); err != nil {
4334 return err
4335 }
4336
4337 if t.OwnerDid == nil {
4338 if _, err := cw.Write(cbg.CborNull); err != nil {
4339 return err
4340 }
4341 } else {
4342 if len(*t.OwnerDid) > 1000000 {
4343 return xerrors.Errorf("Value in field t.OwnerDid was too long")
4344 }
4345
4346 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.OwnerDid))); err != nil {
4347 return err
4348 }
4349 if _, err := cw.WriteString(string(*t.OwnerDid)); err != nil {
4350 return err
4351 }
4352 }
4353 }
4354
4355 // t.PushOptions ([]string) (slice)
4356 if t.PushOptions != nil {
4357
4358 if len("pushOptions") > 1000000 {
4359 return xerrors.Errorf("Value in field \"pushOptions\" was too long")
4360 }
4361
4362 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pushOptions"))); err != nil {
4363 return err
4364 }
4365 if _, err := cw.WriteString(string("pushOptions")); err != nil {
4366 return err
4367 }
4368
4369 if len(t.PushOptions) > 8192 {
4370 return xerrors.Errorf("Slice value in field t.PushOptions was too long")
4371 }
4372
4373 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.PushOptions))); err != nil {
4374 return err
4375 }
4376 for _, v := range t.PushOptions {
4377 if len(v) > 1000000 {
4378 return xerrors.Errorf("Value in field v was too long")
4379 }
4380
4381 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
4382 return err
4383 }
4384 if _, err := cw.WriteString(string(v)); err != nil {
4385 return err
4386 }
4387
4388 }
4389 }
4390
4391 // t.ChangedFiles ([]string) (slice)
4392 if t.ChangedFiles != nil {
4393
4394 if len("changedFiles") > 1000000 {
4395 return xerrors.Errorf("Value in field \"changedFiles\" was too long")
4396 }
4397
4398 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("changedFiles"))); err != nil {
4399 return err
4400 }
4401 if _, err := cw.WriteString(string("changedFiles")); err != nil {
4402 return err
4403 }
4404
4405 if len(t.ChangedFiles) > 8192 {
4406 return xerrors.Errorf("Slice value in field t.ChangedFiles was too long")
4407 }
4408
4409 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ChangedFiles))); err != nil {
4410 return err
4411 }
4412 for _, v := range t.ChangedFiles {
4413 if len(v) > 1000000 {
4414 return xerrors.Errorf("Value in field v was too long")
4415 }
4416
4417 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
4418 return err
4419 }
4420 if _, err := cw.WriteString(string(v)); err != nil {
4421 return err
4422 }
4423
4424 }
4425 }
4426
4427 // t.CommitterDid (string) (string)
4428 if len("committerDid") > 1000000 {
4429 return xerrors.Errorf("Value in field \"committerDid\" was too long")
4430 }
4431
4432 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("committerDid"))); err != nil {
4433 return err
4434 }
4435 if _, err := cw.WriteString(string("committerDid")); err != nil {
4436 return err
4437 }
4438
4439 if len(t.CommitterDid) > 1000000 {
4440 return xerrors.Errorf("Value in field t.CommitterDid was too long")
4441 }
4442
4443 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CommitterDid))); err != nil {
4444 return err
4445 }
4446 if _, err := cw.WriteString(string(t.CommitterDid)); err != nil {
4447 return err
4448 }
4449 return nil
4450}
4451
4452func (t *GitRefUpdate) UnmarshalCBOR(r io.Reader) (err error) {
4453 *t = GitRefUpdate{}
4454
4455 cr := cbg.NewCborReader(r)
4456
4457 maj, extra, err := cr.ReadHeader()
4458 if err != nil {
4459 return err
4460 }
4461 defer func() {
4462 if err == io.EOF {
4463 err = io.ErrUnexpectedEOF
4464 }
4465 }()
4466
4467 if maj != cbg.MajMap {
4468 return fmt.Errorf("cbor input should be of type map")
4469 }
4470
4471 if extra > cbg.MaxLength {
4472 return fmt.Errorf("GitRefUpdate: map struct too large (%d)", extra)
4473 }
4474
4475 n := extra
4476
4477 nameBuf := make([]byte, 12)
4478 for i := uint64(0); i < n; i++ {
4479 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4480 if err != nil {
4481 return err
4482 }
4483
4484 if !ok {
4485 // Field doesn't exist on this type, so ignore it
4486 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4487 return err
4488 }
4489 continue
4490 }
4491
4492 switch string(nameBuf[:nameLen]) {
4493 // t.Ref (string) (string)
4494 case "ref":
4495
4496 {
4497 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4498 if err != nil {
4499 return err
4500 }
4501
4502 t.Ref = string(sval)
4503 }
4504 // t.Meta (tangled.GitRefUpdate_Meta) (struct)
4505 case "meta":
4506
4507 {
4508
4509 b, err := cr.ReadByte()
4510 if err != nil {
4511 return err
4512 }
4513 if b != cbg.CborNull[0] {
4514 if err := cr.UnreadByte(); err != nil {
4515 return err
4516 }
4517 t.Meta = new(GitRefUpdate_Meta)
4518 if err := t.Meta.UnmarshalCBOR(cr); err != nil {
4519 return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err)
4520 }
4521 }
4522
4523 }
4524 // t.Repo (string) (string)
4525 case "repo":
4526
4527 {
4528 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4529 if err != nil {
4530 return err
4531 }
4532
4533 t.Repo = string(sval)
4534 }
4535 // t.LexiconTypeID (string) (string)
4536 case "$type":
4537
4538 {
4539 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4540 if err != nil {
4541 return err
4542 }
4543
4544 t.LexiconTypeID = string(sval)
4545 }
4546 // t.NewSha (string) (string)
4547 case "newSha":
4548
4549 {
4550 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4551 if err != nil {
4552 return err
4553 }
4554
4555 t.NewSha = string(sval)
4556 }
4557 // t.OldSha (string) (string)
4558 case "oldSha":
4559
4560 {
4561 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4562 if err != nil {
4563 return err
4564 }
4565
4566 t.OldSha = string(sval)
4567 }
4568 // t.OwnerDid (string) (string)
4569 case "ownerDid":
4570
4571 {
4572 b, err := cr.ReadByte()
4573 if err != nil {
4574 return err
4575 }
4576 if b != cbg.CborNull[0] {
4577 if err := cr.UnreadByte(); err != nil {
4578 return err
4579 }
4580
4581 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4582 if err != nil {
4583 return err
4584 }
4585
4586 t.OwnerDid = (*string)(&sval)
4587 }
4588 }
4589 // t.PushOptions ([]string) (slice)
4590 case "pushOptions":
4591
4592 maj, extra, err = cr.ReadHeader()
4593 if err != nil {
4594 return err
4595 }
4596
4597 if extra > 8192 {
4598 return fmt.Errorf("t.PushOptions: array too large (%d)", extra)
4599 }
4600
4601 if maj != cbg.MajArray {
4602 return fmt.Errorf("expected cbor array")
4603 }
4604
4605 if extra > 0 {
4606 t.PushOptions = make([]string, extra)
4607 }
4608
4609 for i := 0; i < int(extra); i++ {
4610 {
4611 var maj byte
4612 var extra uint64
4613 var err error
4614 _ = maj
4615 _ = extra
4616 _ = err
4617
4618 {
4619 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4620 if err != nil {
4621 return err
4622 }
4623
4624 t.PushOptions[i] = string(sval)
4625 }
4626
4627 }
4628 }
4629 // t.ChangedFiles ([]string) (slice)
4630 case "changedFiles":
4631
4632 maj, extra, err = cr.ReadHeader()
4633 if err != nil {
4634 return err
4635 }
4636
4637 if extra > 8192 {
4638 return fmt.Errorf("t.ChangedFiles: array too large (%d)", extra)
4639 }
4640
4641 if maj != cbg.MajArray {
4642 return fmt.Errorf("expected cbor array")
4643 }
4644
4645 if extra > 0 {
4646 t.ChangedFiles = make([]string, extra)
4647 }
4648
4649 for i := 0; i < int(extra); i++ {
4650 {
4651 var maj byte
4652 var extra uint64
4653 var err error
4654 _ = maj
4655 _ = extra
4656 _ = err
4657
4658 {
4659 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4660 if err != nil {
4661 return err
4662 }
4663
4664 t.ChangedFiles[i] = string(sval)
4665 }
4666
4667 }
4668 }
4669 // t.CommitterDid (string) (string)
4670 case "committerDid":
4671
4672 {
4673 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4674 if err != nil {
4675 return err
4676 }
4677
4678 t.CommitterDid = string(sval)
4679 }
4680
4681 default:
4682 // Field doesn't exist on this type, so ignore it
4683 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4684 return err
4685 }
4686 }
4687 }
4688
4689 return nil
4690}
4691func (t *GitRefUpdate_CommitCountBreakdown) MarshalCBOR(w io.Writer) error {
4692 if t == nil {
4693 _, err := w.Write(cbg.CborNull)
4694 return err
4695 }
4696
4697 cw := cbg.NewCborWriter(w)
4698 fieldCount := 1
4699
4700 if t.ByEmail == nil {
4701 fieldCount--
4702 }
4703
4704 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4705 return err
4706 }
4707
4708 // t.ByEmail ([]*tangled.GitRefUpdate_IndividualEmailCommitCount) (slice)
4709 if t.ByEmail != nil {
4710
4711 if len("byEmail") > 1000000 {
4712 return xerrors.Errorf("Value in field \"byEmail\" was too long")
4713 }
4714
4715 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byEmail"))); err != nil {
4716 return err
4717 }
4718 if _, err := cw.WriteString(string("byEmail")); err != nil {
4719 return err
4720 }
4721
4722 if len(t.ByEmail) > 8192 {
4723 return xerrors.Errorf("Slice value in field t.ByEmail was too long")
4724 }
4725
4726 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ByEmail))); err != nil {
4727 return err
4728 }
4729 for _, v := range t.ByEmail {
4730 if err := v.MarshalCBOR(cw); err != nil {
4731 return err
4732 }
4733
4734 }
4735 }
4736 return nil
4737}
4738
4739func (t *GitRefUpdate_CommitCountBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
4740 *t = GitRefUpdate_CommitCountBreakdown{}
4741
4742 cr := cbg.NewCborReader(r)
4743
4744 maj, extra, err := cr.ReadHeader()
4745 if err != nil {
4746 return err
4747 }
4748 defer func() {
4749 if err == io.EOF {
4750 err = io.ErrUnexpectedEOF
4751 }
4752 }()
4753
4754 if maj != cbg.MajMap {
4755 return fmt.Errorf("cbor input should be of type map")
4756 }
4757
4758 if extra > cbg.MaxLength {
4759 return fmt.Errorf("GitRefUpdate_CommitCountBreakdown: map struct too large (%d)", extra)
4760 }
4761
4762 n := extra
4763
4764 nameBuf := make([]byte, 7)
4765 for i := uint64(0); i < n; i++ {
4766 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4767 if err != nil {
4768 return err
4769 }
4770
4771 if !ok {
4772 // Field doesn't exist on this type, so ignore it
4773 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4774 return err
4775 }
4776 continue
4777 }
4778
4779 switch string(nameBuf[:nameLen]) {
4780 // t.ByEmail ([]*tangled.GitRefUpdate_IndividualEmailCommitCount) (slice)
4781 case "byEmail":
4782
4783 maj, extra, err = cr.ReadHeader()
4784 if err != nil {
4785 return err
4786 }
4787
4788 if extra > 8192 {
4789 return fmt.Errorf("t.ByEmail: array too large (%d)", extra)
4790 }
4791
4792 if maj != cbg.MajArray {
4793 return fmt.Errorf("expected cbor array")
4794 }
4795
4796 if extra > 0 {
4797 t.ByEmail = make([]*GitRefUpdate_IndividualEmailCommitCount, extra)
4798 }
4799
4800 for i := 0; i < int(extra); i++ {
4801 {
4802 var maj byte
4803 var extra uint64
4804 var err error
4805 _ = maj
4806 _ = extra
4807 _ = err
4808
4809 {
4810
4811 b, err := cr.ReadByte()
4812 if err != nil {
4813 return err
4814 }
4815 if b != cbg.CborNull[0] {
4816 if err := cr.UnreadByte(); err != nil {
4817 return err
4818 }
4819 t.ByEmail[i] = new(GitRefUpdate_IndividualEmailCommitCount)
4820 if err := t.ByEmail[i].UnmarshalCBOR(cr); err != nil {
4821 return xerrors.Errorf("unmarshaling t.ByEmail[i] pointer: %w", err)
4822 }
4823 }
4824
4825 }
4826
4827 }
4828 }
4829
4830 default:
4831 // Field doesn't exist on this type, so ignore it
4832 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4833 return err
4834 }
4835 }
4836 }
4837
4838 return nil
4839}
4840func (t *GitRefUpdate_IndividualEmailCommitCount) MarshalCBOR(w io.Writer) error {
4841 if t == nil {
4842 _, err := w.Write(cbg.CborNull)
4843 return err
4844 }
4845
4846 cw := cbg.NewCborWriter(w)
4847
4848 if _, err := cw.Write([]byte{162}); err != nil {
4849 return err
4850 }
4851
4852 // t.Count (int64) (int64)
4853 if len("count") > 1000000 {
4854 return xerrors.Errorf("Value in field \"count\" was too long")
4855 }
4856
4857 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("count"))); err != nil {
4858 return err
4859 }
4860 if _, err := cw.WriteString(string("count")); err != nil {
4861 return err
4862 }
4863
4864 if t.Count >= 0 {
4865 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Count)); err != nil {
4866 return err
4867 }
4868 } else {
4869 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Count-1)); err != nil {
4870 return err
4871 }
4872 }
4873
4874 // t.Email (string) (string)
4875 if len("email") > 1000000 {
4876 return xerrors.Errorf("Value in field \"email\" was too long")
4877 }
4878
4879 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("email"))); err != nil {
4880 return err
4881 }
4882 if _, err := cw.WriteString(string("email")); err != nil {
4883 return err
4884 }
4885
4886 if len(t.Email) > 1000000 {
4887 return xerrors.Errorf("Value in field t.Email was too long")
4888 }
4889
4890 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Email))); err != nil {
4891 return err
4892 }
4893 if _, err := cw.WriteString(string(t.Email)); err != nil {
4894 return err
4895 }
4896 return nil
4897}
4898
4899func (t *GitRefUpdate_IndividualEmailCommitCount) UnmarshalCBOR(r io.Reader) (err error) {
4900 *t = GitRefUpdate_IndividualEmailCommitCount{}
4901
4902 cr := cbg.NewCborReader(r)
4903
4904 maj, extra, err := cr.ReadHeader()
4905 if err != nil {
4906 return err
4907 }
4908 defer func() {
4909 if err == io.EOF {
4910 err = io.ErrUnexpectedEOF
4911 }
4912 }()
4913
4914 if maj != cbg.MajMap {
4915 return fmt.Errorf("cbor input should be of type map")
4916 }
4917
4918 if extra > cbg.MaxLength {
4919 return fmt.Errorf("GitRefUpdate_IndividualEmailCommitCount: map struct too large (%d)", extra)
4920 }
4921
4922 n := extra
4923
4924 nameBuf := make([]byte, 5)
4925 for i := uint64(0); i < n; i++ {
4926 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4927 if err != nil {
4928 return err
4929 }
4930
4931 if !ok {
4932 // Field doesn't exist on this type, so ignore it
4933 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4934 return err
4935 }
4936 continue
4937 }
4938
4939 switch string(nameBuf[:nameLen]) {
4940 // t.Count (int64) (int64)
4941 case "count":
4942 {
4943 maj, extra, err := cr.ReadHeader()
4944 if err != nil {
4945 return err
4946 }
4947 var extraI int64
4948 switch maj {
4949 case cbg.MajUnsignedInt:
4950 extraI = int64(extra)
4951 if extraI < 0 {
4952 return fmt.Errorf("int64 positive overflow")
4953 }
4954 case cbg.MajNegativeInt:
4955 extraI = int64(extra)
4956 if extraI < 0 {
4957 return fmt.Errorf("int64 negative overflow")
4958 }
4959 extraI = -1 - extraI
4960 default:
4961 return fmt.Errorf("wrong type for int64 field: %d", maj)
4962 }
4963
4964 t.Count = int64(extraI)
4965 }
4966 // t.Email (string) (string)
4967 case "email":
4968
4969 {
4970 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4971 if err != nil {
4972 return err
4973 }
4974
4975 t.Email = string(sval)
4976 }
4977
4978 default:
4979 // Field doesn't exist on this type, so ignore it
4980 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4981 return err
4982 }
4983 }
4984 }
4985
4986 return nil
4987}
4988func (t *GitRefUpdate_IndividualLanguageSize) MarshalCBOR(w io.Writer) error {
4989 if t == nil {
4990 _, err := w.Write(cbg.CborNull)
4991 return err
4992 }
4993
4994 cw := cbg.NewCborWriter(w)
4995
4996 if _, err := cw.Write([]byte{162}); err != nil {
4997 return err
4998 }
4999
5000 // t.Lang (string) (string)
5001 if len("lang") > 1000000 {
5002 return xerrors.Errorf("Value in field \"lang\" was too long")
5003 }
5004
5005 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil {
5006 return err
5007 }
5008 if _, err := cw.WriteString(string("lang")); err != nil {
5009 return err
5010 }
5011
5012 if len(t.Lang) > 1000000 {
5013 return xerrors.Errorf("Value in field t.Lang was too long")
5014 }
5015
5016 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil {
5017 return err
5018 }
5019 if _, err := cw.WriteString(string(t.Lang)); err != nil {
5020 return err
5021 }
5022
5023 // t.Size (int64) (int64)
5024 if len("size") > 1000000 {
5025 return xerrors.Errorf("Value in field \"size\" was too long")
5026 }
5027
5028 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil {
5029 return err
5030 }
5031 if _, err := cw.WriteString(string("size")); err != nil {
5032 return err
5033 }
5034
5035 if t.Size >= 0 {
5036 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil {
5037 return err
5038 }
5039 } else {
5040 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); err != nil {
5041 return err
5042 }
5043 }
5044
5045 return nil
5046}
5047
5048func (t *GitRefUpdate_IndividualLanguageSize) UnmarshalCBOR(r io.Reader) (err error) {
5049 *t = GitRefUpdate_IndividualLanguageSize{}
5050
5051 cr := cbg.NewCborReader(r)
5052
5053 maj, extra, err := cr.ReadHeader()
5054 if err != nil {
5055 return err
5056 }
5057 defer func() {
5058 if err == io.EOF {
5059 err = io.ErrUnexpectedEOF
5060 }
5061 }()
5062
5063 if maj != cbg.MajMap {
5064 return fmt.Errorf("cbor input should be of type map")
5065 }
5066
5067 if extra > cbg.MaxLength {
5068 return fmt.Errorf("GitRefUpdate_IndividualLanguageSize: map struct too large (%d)", extra)
5069 }
5070
5071 n := extra
5072
5073 nameBuf := make([]byte, 4)
5074 for i := uint64(0); i < n; i++ {
5075 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5076 if err != nil {
5077 return err
5078 }
5079
5080 if !ok {
5081 // Field doesn't exist on this type, so ignore it
5082 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5083 return err
5084 }
5085 continue
5086 }
5087
5088 switch string(nameBuf[:nameLen]) {
5089 // t.Lang (string) (string)
5090 case "lang":
5091
5092 {
5093 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5094 if err != nil {
5095 return err
5096 }
5097
5098 t.Lang = string(sval)
5099 }
5100 // t.Size (int64) (int64)
5101 case "size":
5102 {
5103 maj, extra, err := cr.ReadHeader()
5104 if err != nil {
5105 return err
5106 }
5107 var extraI int64
5108 switch maj {
5109 case cbg.MajUnsignedInt:
5110 extraI = int64(extra)
5111 if extraI < 0 {
5112 return fmt.Errorf("int64 positive overflow")
5113 }
5114 case cbg.MajNegativeInt:
5115 extraI = int64(extra)
5116 if extraI < 0 {
5117 return fmt.Errorf("int64 negative overflow")
5118 }
5119 extraI = -1 - extraI
5120 default:
5121 return fmt.Errorf("wrong type for int64 field: %d", maj)
5122 }
5123
5124 t.Size = int64(extraI)
5125 }
5126
5127 default:
5128 // Field doesn't exist on this type, so ignore it
5129 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5130 return err
5131 }
5132 }
5133 }
5134
5135 return nil
5136}
5137func (t *GitRefUpdate_LangBreakdown) MarshalCBOR(w io.Writer) error {
5138 if t == nil {
5139 _, err := w.Write(cbg.CborNull)
5140 return err
5141 }
5142
5143 cw := cbg.NewCborWriter(w)
5144 fieldCount := 1
5145
5146 if t.Inputs == nil {
5147 fieldCount--
5148 }
5149
5150 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5151 return err
5152 }
5153
5154 // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice)
5155 if t.Inputs != nil {
5156
5157 if len("inputs") > 1000000 {
5158 return xerrors.Errorf("Value in field \"inputs\" was too long")
5159 }
5160
5161 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
5162 return err
5163 }
5164 if _, err := cw.WriteString(string("inputs")); err != nil {
5165 return err
5166 }
5167
5168 if len(t.Inputs) > 8192 {
5169 return xerrors.Errorf("Slice value in field t.Inputs was too long")
5170 }
5171
5172 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
5173 return err
5174 }
5175 for _, v := range t.Inputs {
5176 if err := v.MarshalCBOR(cw); err != nil {
5177 return err
5178 }
5179
5180 }
5181 }
5182 return nil
5183}
5184
5185func (t *GitRefUpdate_LangBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
5186 *t = GitRefUpdate_LangBreakdown{}
5187
5188 cr := cbg.NewCborReader(r)
5189
5190 maj, extra, err := cr.ReadHeader()
5191 if err != nil {
5192 return err
5193 }
5194 defer func() {
5195 if err == io.EOF {
5196 err = io.ErrUnexpectedEOF
5197 }
5198 }()
5199
5200 if maj != cbg.MajMap {
5201 return fmt.Errorf("cbor input should be of type map")
5202 }
5203
5204 if extra > cbg.MaxLength {
5205 return fmt.Errorf("GitRefUpdate_LangBreakdown: map struct too large (%d)", extra)
5206 }
5207
5208 n := extra
5209
5210 nameBuf := make([]byte, 6)
5211 for i := uint64(0); i < n; i++ {
5212 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5213 if err != nil {
5214 return err
5215 }
5216
5217 if !ok {
5218 // Field doesn't exist on this type, so ignore it
5219 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5220 return err
5221 }
5222 continue
5223 }
5224
5225 switch string(nameBuf[:nameLen]) {
5226 // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice)
5227 case "inputs":
5228
5229 maj, extra, err = cr.ReadHeader()
5230 if err != nil {
5231 return err
5232 }
5233
5234 if extra > 8192 {
5235 return fmt.Errorf("t.Inputs: array too large (%d)", extra)
5236 }
5237
5238 if maj != cbg.MajArray {
5239 return fmt.Errorf("expected cbor array")
5240 }
5241
5242 if extra > 0 {
5243 t.Inputs = make([]*GitRefUpdate_IndividualLanguageSize, extra)
5244 }
5245
5246 for i := 0; i < int(extra); i++ {
5247 {
5248 var maj byte
5249 var extra uint64
5250 var err error
5251 _ = maj
5252 _ = extra
5253 _ = err
5254
5255 {
5256
5257 b, err := cr.ReadByte()
5258 if err != nil {
5259 return err
5260 }
5261 if b != cbg.CborNull[0] {
5262 if err := cr.UnreadByte(); err != nil {
5263 return err
5264 }
5265 t.Inputs[i] = new(GitRefUpdate_IndividualLanguageSize)
5266 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
5267 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
5268 }
5269 }
5270
5271 }
5272
5273 }
5274 }
5275
5276 default:
5277 // Field doesn't exist on this type, so ignore it
5278 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5279 return err
5280 }
5281 }
5282 }
5283
5284 return nil
5285}
5286func (t *GitRefUpdate_Meta) MarshalCBOR(w io.Writer) error {
5287 if t == nil {
5288 _, err := w.Write(cbg.CborNull)
5289 return err
5290 }
5291
5292 cw := cbg.NewCborWriter(w)
5293 fieldCount := 3
5294
5295 if t.LangBreakdown == nil {
5296 fieldCount--
5297 }
5298
5299 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5300 return err
5301 }
5302
5303 // t.CommitCount (tangled.GitRefUpdate_CommitCountBreakdown) (struct)
5304 if len("commitCount") > 1000000 {
5305 return xerrors.Errorf("Value in field \"commitCount\" was too long")
5306 }
5307
5308 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commitCount"))); err != nil {
5309 return err
5310 }
5311 if _, err := cw.WriteString(string("commitCount")); err != nil {
5312 return err
5313 }
5314
5315 if err := t.CommitCount.MarshalCBOR(cw); err != nil {
5316 return err
5317 }
5318
5319 // t.IsDefaultRef (bool) (bool)
5320 if len("isDefaultRef") > 1000000 {
5321 return xerrors.Errorf("Value in field \"isDefaultRef\" was too long")
5322 }
5323
5324 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("isDefaultRef"))); err != nil {
5325 return err
5326 }
5327 if _, err := cw.WriteString(string("isDefaultRef")); err != nil {
5328 return err
5329 }
5330
5331 if err := cbg.WriteBool(w, t.IsDefaultRef); err != nil {
5332 return err
5333 }
5334
5335 // t.LangBreakdown (tangled.GitRefUpdate_LangBreakdown) (struct)
5336 if t.LangBreakdown != nil {
5337
5338 if len("langBreakdown") > 1000000 {
5339 return xerrors.Errorf("Value in field \"langBreakdown\" was too long")
5340 }
5341
5342 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("langBreakdown"))); err != nil {
5343 return err
5344 }
5345 if _, err := cw.WriteString(string("langBreakdown")); err != nil {
5346 return err
5347 }
5348
5349 if err := t.LangBreakdown.MarshalCBOR(cw); err != nil {
5350 return err
5351 }
5352 }
5353 return nil
5354}
5355
5356func (t *GitRefUpdate_Meta) UnmarshalCBOR(r io.Reader) (err error) {
5357 *t = GitRefUpdate_Meta{}
5358
5359 cr := cbg.NewCborReader(r)
5360
5361 maj, extra, err := cr.ReadHeader()
5362 if err != nil {
5363 return err
5364 }
5365 defer func() {
5366 if err == io.EOF {
5367 err = io.ErrUnexpectedEOF
5368 }
5369 }()
5370
5371 if maj != cbg.MajMap {
5372 return fmt.Errorf("cbor input should be of type map")
5373 }
5374
5375 if extra > cbg.MaxLength {
5376 return fmt.Errorf("GitRefUpdate_Meta: map struct too large (%d)", extra)
5377 }
5378
5379 n := extra
5380
5381 nameBuf := make([]byte, 13)
5382 for i := uint64(0); i < n; i++ {
5383 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5384 if err != nil {
5385 return err
5386 }
5387
5388 if !ok {
5389 // Field doesn't exist on this type, so ignore it
5390 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5391 return err
5392 }
5393 continue
5394 }
5395
5396 switch string(nameBuf[:nameLen]) {
5397 // t.CommitCount (tangled.GitRefUpdate_CommitCountBreakdown) (struct)
5398 case "commitCount":
5399
5400 {
5401
5402 b, err := cr.ReadByte()
5403 if err != nil {
5404 return err
5405 }
5406 if b != cbg.CborNull[0] {
5407 if err := cr.UnreadByte(); err != nil {
5408 return err
5409 }
5410 t.CommitCount = new(GitRefUpdate_CommitCountBreakdown)
5411 if err := t.CommitCount.UnmarshalCBOR(cr); err != nil {
5412 return xerrors.Errorf("unmarshaling t.CommitCount pointer: %w", err)
5413 }
5414 }
5415
5416 }
5417 // t.IsDefaultRef (bool) (bool)
5418 case "isDefaultRef":
5419
5420 maj, extra, err = cr.ReadHeader()
5421 if err != nil {
5422 return err
5423 }
5424 if maj != cbg.MajOther {
5425 return fmt.Errorf("booleans must be major type 7")
5426 }
5427 switch extra {
5428 case 20:
5429 t.IsDefaultRef = false
5430 case 21:
5431 t.IsDefaultRef = true
5432 default:
5433 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
5434 }
5435 // t.LangBreakdown (tangled.GitRefUpdate_LangBreakdown) (struct)
5436 case "langBreakdown":
5437
5438 {
5439
5440 b, err := cr.ReadByte()
5441 if err != nil {
5442 return err
5443 }
5444 if b != cbg.CborNull[0] {
5445 if err := cr.UnreadByte(); err != nil {
5446 return err
5447 }
5448 t.LangBreakdown = new(GitRefUpdate_LangBreakdown)
5449 if err := t.LangBreakdown.UnmarshalCBOR(cr); err != nil {
5450 return xerrors.Errorf("unmarshaling t.LangBreakdown pointer: %w", err)
5451 }
5452 }
5453
5454 }
5455
5456 default:
5457 // Field doesn't exist on this type, so ignore it
5458 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5459 return err
5460 }
5461 }
5462 }
5463
5464 return nil
5465}
5466func (t *GraphFollow) MarshalCBOR(w io.Writer) error {
5467 if t == nil {
5468 _, err := w.Write(cbg.CborNull)
5469 return err
5470 }
5471
5472 cw := cbg.NewCborWriter(w)
5473
5474 if _, err := cw.Write([]byte{163}); err != nil {
5475 return err
5476 }
5477
5478 // t.LexiconTypeID (string) (string)
5479 if len("$type") > 1000000 {
5480 return xerrors.Errorf("Value in field \"$type\" was too long")
5481 }
5482
5483 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5484 return err
5485 }
5486 if _, err := cw.WriteString(string("$type")); err != nil {
5487 return err
5488 }
5489
5490 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.graph.follow"))); err != nil {
5491 return err
5492 }
5493 if _, err := cw.WriteString(string("sh.tangled.graph.follow")); err != nil {
5494 return err
5495 }
5496
5497 // t.Subject (string) (string)
5498 if len("subject") > 1000000 {
5499 return xerrors.Errorf("Value in field \"subject\" was too long")
5500 }
5501
5502 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
5503 return err
5504 }
5505 if _, err := cw.WriteString(string("subject")); err != nil {
5506 return err
5507 }
5508
5509 if len(t.Subject) > 1000000 {
5510 return xerrors.Errorf("Value in field t.Subject was too long")
5511 }
5512
5513 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
5514 return err
5515 }
5516 if _, err := cw.WriteString(string(t.Subject)); err != nil {
5517 return err
5518 }
5519
5520 // t.CreatedAt (string) (string)
5521 if len("createdAt") > 1000000 {
5522 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5523 }
5524
5525 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5526 return err
5527 }
5528 if _, err := cw.WriteString(string("createdAt")); err != nil {
5529 return err
5530 }
5531
5532 if len(t.CreatedAt) > 1000000 {
5533 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5534 }
5535
5536 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5537 return err
5538 }
5539 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5540 return err
5541 }
5542 return nil
5543}
5544
5545func (t *GraphFollow) UnmarshalCBOR(r io.Reader) (err error) {
5546 *t = GraphFollow{}
5547
5548 cr := cbg.NewCborReader(r)
5549
5550 maj, extra, err := cr.ReadHeader()
5551 if err != nil {
5552 return err
5553 }
5554 defer func() {
5555 if err == io.EOF {
5556 err = io.ErrUnexpectedEOF
5557 }
5558 }()
5559
5560 if maj != cbg.MajMap {
5561 return fmt.Errorf("cbor input should be of type map")
5562 }
5563
5564 if extra > cbg.MaxLength {
5565 return fmt.Errorf("GraphFollow: map struct too large (%d)", extra)
5566 }
5567
5568 n := extra
5569
5570 nameBuf := make([]byte, 9)
5571 for i := uint64(0); i < n; i++ {
5572 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5573 if err != nil {
5574 return err
5575 }
5576
5577 if !ok {
5578 // Field doesn't exist on this type, so ignore it
5579 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5580 return err
5581 }
5582 continue
5583 }
5584
5585 switch string(nameBuf[:nameLen]) {
5586 // t.LexiconTypeID (string) (string)
5587 case "$type":
5588
5589 {
5590 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5591 if err != nil {
5592 return err
5593 }
5594
5595 t.LexiconTypeID = string(sval)
5596 }
5597 // t.Subject (string) (string)
5598 case "subject":
5599
5600 {
5601 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5602 if err != nil {
5603 return err
5604 }
5605
5606 t.Subject = string(sval)
5607 }
5608 // t.CreatedAt (string) (string)
5609 case "createdAt":
5610
5611 {
5612 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5613 if err != nil {
5614 return err
5615 }
5616
5617 t.CreatedAt = string(sval)
5618 }
5619
5620 default:
5621 // Field doesn't exist on this type, so ignore it
5622 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5623 return err
5624 }
5625 }
5626 }
5627
5628 return nil
5629}
5630func (t *GraphVouch) MarshalCBOR(w io.Writer) error {
5631 if t == nil {
5632 _, err := w.Write(cbg.CborNull)
5633 return err
5634 }
5635
5636 cw := cbg.NewCborWriter(w)
5637 fieldCount := 5
5638
5639 if t.Evidences == nil {
5640 fieldCount--
5641 }
5642
5643 if t.Reason == nil {
5644 fieldCount--
5645 }
5646
5647 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5648 return err
5649 }
5650
5651 // t.Kind (string) (string)
5652 if len("kind") > 1000000 {
5653 return xerrors.Errorf("Value in field \"kind\" was too long")
5654 }
5655
5656 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("kind"))); err != nil {
5657 return err
5658 }
5659 if _, err := cw.WriteString(string("kind")); err != nil {
5660 return err
5661 }
5662
5663 if len(t.Kind) > 1000000 {
5664 return xerrors.Errorf("Value in field t.Kind was too long")
5665 }
5666
5667 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Kind))); err != nil {
5668 return err
5669 }
5670 if _, err := cw.WriteString(string(t.Kind)); err != nil {
5671 return err
5672 }
5673
5674 // t.LexiconTypeID (string) (string)
5675 if len("$type") > 1000000 {
5676 return xerrors.Errorf("Value in field \"$type\" was too long")
5677 }
5678
5679 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5680 return err
5681 }
5682 if _, err := cw.WriteString(string("$type")); err != nil {
5683 return err
5684 }
5685
5686 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.graph.vouch"))); err != nil {
5687 return err
5688 }
5689 if _, err := cw.WriteString(string("sh.tangled.graph.vouch")); err != nil {
5690 return err
5691 }
5692
5693 // t.Reason (string) (string)
5694 if t.Reason != nil {
5695
5696 if len("reason") > 1000000 {
5697 return xerrors.Errorf("Value in field \"reason\" was too long")
5698 }
5699
5700 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("reason"))); err != nil {
5701 return err
5702 }
5703 if _, err := cw.WriteString(string("reason")); err != nil {
5704 return err
5705 }
5706
5707 if t.Reason == nil {
5708 if _, err := cw.Write(cbg.CborNull); err != nil {
5709 return err
5710 }
5711 } else {
5712 if len(*t.Reason) > 1000000 {
5713 return xerrors.Errorf("Value in field t.Reason was too long")
5714 }
5715
5716 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Reason))); err != nil {
5717 return err
5718 }
5719 if _, err := cw.WriteString(string(*t.Reason)); err != nil {
5720 return err
5721 }
5722 }
5723 }
5724
5725 // t.CreatedAt (string) (string)
5726 if len("createdAt") > 1000000 {
5727 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5728 }
5729
5730 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5731 return err
5732 }
5733 if _, err := cw.WriteString(string("createdAt")); err != nil {
5734 return err
5735 }
5736
5737 if len(t.CreatedAt) > 1000000 {
5738 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5739 }
5740
5741 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5742 return err
5743 }
5744 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5745 return err
5746 }
5747
5748 // t.Evidences ([]string) (slice)
5749 if t.Evidences != nil {
5750
5751 if len("evidences") > 1000000 {
5752 return xerrors.Errorf("Value in field \"evidences\" was too long")
5753 }
5754
5755 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("evidences"))); err != nil {
5756 return err
5757 }
5758 if _, err := cw.WriteString(string("evidences")); err != nil {
5759 return err
5760 }
5761
5762 if len(t.Evidences) > 8192 {
5763 return xerrors.Errorf("Slice value in field t.Evidences was too long")
5764 }
5765
5766 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Evidences))); err != nil {
5767 return err
5768 }
5769 for _, v := range t.Evidences {
5770 if len(v) > 1000000 {
5771 return xerrors.Errorf("Value in field v was too long")
5772 }
5773
5774 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
5775 return err
5776 }
5777 if _, err := cw.WriteString(string(v)); err != nil {
5778 return err
5779 }
5780
5781 }
5782 }
5783 return nil
5784}
5785
5786func (t *GraphVouch) UnmarshalCBOR(r io.Reader) (err error) {
5787 *t = GraphVouch{}
5788
5789 cr := cbg.NewCborReader(r)
5790
5791 maj, extra, err := cr.ReadHeader()
5792 if err != nil {
5793 return err
5794 }
5795 defer func() {
5796 if err == io.EOF {
5797 err = io.ErrUnexpectedEOF
5798 }
5799 }()
5800
5801 if maj != cbg.MajMap {
5802 return fmt.Errorf("cbor input should be of type map")
5803 }
5804
5805 if extra > cbg.MaxLength {
5806 return fmt.Errorf("GraphVouch: map struct too large (%d)", extra)
5807 }
5808
5809 n := extra
5810
5811 nameBuf := make([]byte, 9)
5812 for i := uint64(0); i < n; i++ {
5813 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5814 if err != nil {
5815 return err
5816 }
5817
5818 if !ok {
5819 // Field doesn't exist on this type, so ignore it
5820 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5821 return err
5822 }
5823 continue
5824 }
5825
5826 switch string(nameBuf[:nameLen]) {
5827 // t.Kind (string) (string)
5828 case "kind":
5829
5830 {
5831 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5832 if err != nil {
5833 return err
5834 }
5835
5836 t.Kind = string(sval)
5837 }
5838 // t.LexiconTypeID (string) (string)
5839 case "$type":
5840
5841 {
5842 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5843 if err != nil {
5844 return err
5845 }
5846
5847 t.LexiconTypeID = string(sval)
5848 }
5849 // t.Reason (string) (string)
5850 case "reason":
5851
5852 {
5853 b, err := cr.ReadByte()
5854 if err != nil {
5855 return err
5856 }
5857 if b != cbg.CborNull[0] {
5858 if err := cr.UnreadByte(); err != nil {
5859 return err
5860 }
5861
5862 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5863 if err != nil {
5864 return err
5865 }
5866
5867 t.Reason = (*string)(&sval)
5868 }
5869 }
5870 // t.CreatedAt (string) (string)
5871 case "createdAt":
5872
5873 {
5874 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5875 if err != nil {
5876 return err
5877 }
5878
5879 t.CreatedAt = string(sval)
5880 }
5881 // t.Evidences ([]string) (slice)
5882 case "evidences":
5883
5884 maj, extra, err = cr.ReadHeader()
5885 if err != nil {
5886 return err
5887 }
5888
5889 if extra > 8192 {
5890 return fmt.Errorf("t.Evidences: array too large (%d)", extra)
5891 }
5892
5893 if maj != cbg.MajArray {
5894 return fmt.Errorf("expected cbor array")
5895 }
5896
5897 if extra > 0 {
5898 t.Evidences = make([]string, extra)
5899 }
5900
5901 for i := 0; i < int(extra); i++ {
5902 {
5903 var maj byte
5904 var extra uint64
5905 var err error
5906 _ = maj
5907 _ = extra
5908 _ = err
5909
5910 {
5911 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5912 if err != nil {
5913 return err
5914 }
5915
5916 t.Evidences[i] = string(sval)
5917 }
5918
5919 }
5920 }
5921
5922 default:
5923 // Field doesn't exist on this type, so ignore it
5924 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5925 return err
5926 }
5927 }
5928 }
5929
5930 return nil
5931}
5932func (t *Knot) MarshalCBOR(w io.Writer) error {
5933 if t == nil {
5934 _, err := w.Write(cbg.CborNull)
5935 return err
5936 }
5937
5938 cw := cbg.NewCborWriter(w)
5939
5940 if _, err := cw.Write([]byte{162}); err != nil {
5941 return err
5942 }
5943
5944 // t.LexiconTypeID (string) (string)
5945 if len("$type") > 1000000 {
5946 return xerrors.Errorf("Value in field \"$type\" was too long")
5947 }
5948
5949 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5950 return err
5951 }
5952 if _, err := cw.WriteString(string("$type")); err != nil {
5953 return err
5954 }
5955
5956 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot"))); err != nil {
5957 return err
5958 }
5959 if _, err := cw.WriteString(string("sh.tangled.knot")); err != nil {
5960 return err
5961 }
5962
5963 // t.CreatedAt (string) (string)
5964 if len("createdAt") > 1000000 {
5965 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5966 }
5967
5968 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5969 return err
5970 }
5971 if _, err := cw.WriteString(string("createdAt")); err != nil {
5972 return err
5973 }
5974
5975 if len(t.CreatedAt) > 1000000 {
5976 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5977 }
5978
5979 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5980 return err
5981 }
5982 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5983 return err
5984 }
5985 return nil
5986}
5987
5988func (t *Knot) UnmarshalCBOR(r io.Reader) (err error) {
5989 *t = Knot{}
5990
5991 cr := cbg.NewCborReader(r)
5992
5993 maj, extra, err := cr.ReadHeader()
5994 if err != nil {
5995 return err
5996 }
5997 defer func() {
5998 if err == io.EOF {
5999 err = io.ErrUnexpectedEOF
6000 }
6001 }()
6002
6003 if maj != cbg.MajMap {
6004 return fmt.Errorf("cbor input should be of type map")
6005 }
6006
6007 if extra > cbg.MaxLength {
6008 return fmt.Errorf("Knot: map struct too large (%d)", extra)
6009 }
6010
6011 n := extra
6012
6013 nameBuf := make([]byte, 9)
6014 for i := uint64(0); i < n; i++ {
6015 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6016 if err != nil {
6017 return err
6018 }
6019
6020 if !ok {
6021 // Field doesn't exist on this type, so ignore it
6022 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6023 return err
6024 }
6025 continue
6026 }
6027
6028 switch string(nameBuf[:nameLen]) {
6029 // t.LexiconTypeID (string) (string)
6030 case "$type":
6031
6032 {
6033 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6034 if err != nil {
6035 return err
6036 }
6037
6038 t.LexiconTypeID = string(sval)
6039 }
6040 // t.CreatedAt (string) (string)
6041 case "createdAt":
6042
6043 {
6044 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6045 if err != nil {
6046 return err
6047 }
6048
6049 t.CreatedAt = string(sval)
6050 }
6051
6052 default:
6053 // Field doesn't exist on this type, so ignore it
6054 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6055 return err
6056 }
6057 }
6058 }
6059
6060 return nil
6061}
6062func (t *KnotMember) MarshalCBOR(w io.Writer) error {
6063 if t == nil {
6064 _, err := w.Write(cbg.CborNull)
6065 return err
6066 }
6067
6068 cw := cbg.NewCborWriter(w)
6069
6070 if _, err := cw.Write([]byte{164}); err != nil {
6071 return err
6072 }
6073
6074 // t.LexiconTypeID (string) (string)
6075 if len("$type") > 1000000 {
6076 return xerrors.Errorf("Value in field \"$type\" was too long")
6077 }
6078
6079 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6080 return err
6081 }
6082 if _, err := cw.WriteString(string("$type")); err != nil {
6083 return err
6084 }
6085
6086 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot.member"))); err != nil {
6087 return err
6088 }
6089 if _, err := cw.WriteString(string("sh.tangled.knot.member")); err != nil {
6090 return err
6091 }
6092
6093 // t.Domain (string) (string)
6094 if len("domain") > 1000000 {
6095 return xerrors.Errorf("Value in field \"domain\" was too long")
6096 }
6097
6098 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("domain"))); err != nil {
6099 return err
6100 }
6101 if _, err := cw.WriteString(string("domain")); err != nil {
6102 return err
6103 }
6104
6105 if len(t.Domain) > 1000000 {
6106 return xerrors.Errorf("Value in field t.Domain was too long")
6107 }
6108
6109 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Domain))); err != nil {
6110 return err
6111 }
6112 if _, err := cw.WriteString(string(t.Domain)); err != nil {
6113 return err
6114 }
6115
6116 // t.Subject (string) (string)
6117 if len("subject") > 1000000 {
6118 return xerrors.Errorf("Value in field \"subject\" was too long")
6119 }
6120
6121 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
6122 return err
6123 }
6124 if _, err := cw.WriteString(string("subject")); err != nil {
6125 return err
6126 }
6127
6128 if len(t.Subject) > 1000000 {
6129 return xerrors.Errorf("Value in field t.Subject was too long")
6130 }
6131
6132 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
6133 return err
6134 }
6135 if _, err := cw.WriteString(string(t.Subject)); err != nil {
6136 return err
6137 }
6138
6139 // t.CreatedAt (string) (string)
6140 if len("createdAt") > 1000000 {
6141 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6142 }
6143
6144 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6145 return err
6146 }
6147 if _, err := cw.WriteString(string("createdAt")); err != nil {
6148 return err
6149 }
6150
6151 if len(t.CreatedAt) > 1000000 {
6152 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6153 }
6154
6155 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6156 return err
6157 }
6158 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6159 return err
6160 }
6161 return nil
6162}
6163
6164func (t *KnotMember) UnmarshalCBOR(r io.Reader) (err error) {
6165 *t = KnotMember{}
6166
6167 cr := cbg.NewCborReader(r)
6168
6169 maj, extra, err := cr.ReadHeader()
6170 if err != nil {
6171 return err
6172 }
6173 defer func() {
6174 if err == io.EOF {
6175 err = io.ErrUnexpectedEOF
6176 }
6177 }()
6178
6179 if maj != cbg.MajMap {
6180 return fmt.Errorf("cbor input should be of type map")
6181 }
6182
6183 if extra > cbg.MaxLength {
6184 return fmt.Errorf("KnotMember: map struct too large (%d)", extra)
6185 }
6186
6187 n := extra
6188
6189 nameBuf := make([]byte, 9)
6190 for i := uint64(0); i < n; i++ {
6191 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6192 if err != nil {
6193 return err
6194 }
6195
6196 if !ok {
6197 // Field doesn't exist on this type, so ignore it
6198 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6199 return err
6200 }
6201 continue
6202 }
6203
6204 switch string(nameBuf[:nameLen]) {
6205 // t.LexiconTypeID (string) (string)
6206 case "$type":
6207
6208 {
6209 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6210 if err != nil {
6211 return err
6212 }
6213
6214 t.LexiconTypeID = string(sval)
6215 }
6216 // t.Domain (string) (string)
6217 case "domain":
6218
6219 {
6220 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6221 if err != nil {
6222 return err
6223 }
6224
6225 t.Domain = string(sval)
6226 }
6227 // t.Subject (string) (string)
6228 case "subject":
6229
6230 {
6231 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6232 if err != nil {
6233 return err
6234 }
6235
6236 t.Subject = string(sval)
6237 }
6238 // t.CreatedAt (string) (string)
6239 case "createdAt":
6240
6241 {
6242 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6243 if err != nil {
6244 return err
6245 }
6246
6247 t.CreatedAt = string(sval)
6248 }
6249
6250 default:
6251 // Field doesn't exist on this type, so ignore it
6252 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6253 return err
6254 }
6255 }
6256 }
6257
6258 return nil
6259}
6260func (t *LabelDefinition) MarshalCBOR(w io.Writer) error {
6261 if t == nil {
6262 _, err := w.Write(cbg.CborNull)
6263 return err
6264 }
6265
6266 cw := cbg.NewCborWriter(w)
6267 fieldCount := 7
6268
6269 if t.Color == nil {
6270 fieldCount--
6271 }
6272
6273 if t.Multiple == nil {
6274 fieldCount--
6275 }
6276
6277 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6278 return err
6279 }
6280
6281 // t.Name (string) (string)
6282 if len("name") > 1000000 {
6283 return xerrors.Errorf("Value in field \"name\" was too long")
6284 }
6285
6286 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
6287 return err
6288 }
6289 if _, err := cw.WriteString(string("name")); err != nil {
6290 return err
6291 }
6292
6293 if len(t.Name) > 1000000 {
6294 return xerrors.Errorf("Value in field t.Name was too long")
6295 }
6296
6297 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
6298 return err
6299 }
6300 if _, err := cw.WriteString(string(t.Name)); err != nil {
6301 return err
6302 }
6303
6304 // t.LexiconTypeID (string) (string)
6305 if len("$type") > 1000000 {
6306 return xerrors.Errorf("Value in field \"$type\" was too long")
6307 }
6308
6309 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6310 return err
6311 }
6312 if _, err := cw.WriteString(string("$type")); err != nil {
6313 return err
6314 }
6315
6316 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.definition"))); err != nil {
6317 return err
6318 }
6319 if _, err := cw.WriteString(string("sh.tangled.label.definition")); err != nil {
6320 return err
6321 }
6322
6323 // t.Color (string) (string)
6324 if t.Color != nil {
6325
6326 if len("color") > 1000000 {
6327 return xerrors.Errorf("Value in field \"color\" was too long")
6328 }
6329
6330 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("color"))); err != nil {
6331 return err
6332 }
6333 if _, err := cw.WriteString(string("color")); err != nil {
6334 return err
6335 }
6336
6337 if t.Color == nil {
6338 if _, err := cw.Write(cbg.CborNull); err != nil {
6339 return err
6340 }
6341 } else {
6342 if len(*t.Color) > 1000000 {
6343 return xerrors.Errorf("Value in field t.Color was too long")
6344 }
6345
6346 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Color))); err != nil {
6347 return err
6348 }
6349 if _, err := cw.WriteString(string(*t.Color)); err != nil {
6350 return err
6351 }
6352 }
6353 }
6354
6355 // t.Scope ([]string) (slice)
6356 if len("scope") > 1000000 {
6357 return xerrors.Errorf("Value in field \"scope\" was too long")
6358 }
6359
6360 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("scope"))); err != nil {
6361 return err
6362 }
6363 if _, err := cw.WriteString(string("scope")); err != nil {
6364 return err
6365 }
6366
6367 if len(t.Scope) > 8192 {
6368 return xerrors.Errorf("Slice value in field t.Scope was too long")
6369 }
6370
6371 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Scope))); err != nil {
6372 return err
6373 }
6374 for _, v := range t.Scope {
6375 if len(v) > 1000000 {
6376 return xerrors.Errorf("Value in field v was too long")
6377 }
6378
6379 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
6380 return err
6381 }
6382 if _, err := cw.WriteString(string(v)); err != nil {
6383 return err
6384 }
6385
6386 }
6387
6388 // t.Multiple (bool) (bool)
6389 if t.Multiple != nil {
6390
6391 if len("multiple") > 1000000 {
6392 return xerrors.Errorf("Value in field \"multiple\" was too long")
6393 }
6394
6395 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("multiple"))); err != nil {
6396 return err
6397 }
6398 if _, err := cw.WriteString(string("multiple")); err != nil {
6399 return err
6400 }
6401
6402 if t.Multiple == nil {
6403 if _, err := cw.Write(cbg.CborNull); err != nil {
6404 return err
6405 }
6406 } else {
6407 if err := cbg.WriteBool(w, *t.Multiple); err != nil {
6408 return err
6409 }
6410 }
6411 }
6412
6413 // t.CreatedAt (string) (string)
6414 if len("createdAt") > 1000000 {
6415 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6416 }
6417
6418 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6419 return err
6420 }
6421 if _, err := cw.WriteString(string("createdAt")); err != nil {
6422 return err
6423 }
6424
6425 if len(t.CreatedAt) > 1000000 {
6426 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6427 }
6428
6429 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6430 return err
6431 }
6432 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6433 return err
6434 }
6435
6436 // t.ValueType (tangled.LabelDefinition_ValueType) (struct)
6437 if len("valueType") > 1000000 {
6438 return xerrors.Errorf("Value in field \"valueType\" was too long")
6439 }
6440
6441 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("valueType"))); err != nil {
6442 return err
6443 }
6444 if _, err := cw.WriteString(string("valueType")); err != nil {
6445 return err
6446 }
6447
6448 if err := t.ValueType.MarshalCBOR(cw); err != nil {
6449 return err
6450 }
6451 return nil
6452}
6453
6454func (t *LabelDefinition) UnmarshalCBOR(r io.Reader) (err error) {
6455 *t = LabelDefinition{}
6456
6457 cr := cbg.NewCborReader(r)
6458
6459 maj, extra, err := cr.ReadHeader()
6460 if err != nil {
6461 return err
6462 }
6463 defer func() {
6464 if err == io.EOF {
6465 err = io.ErrUnexpectedEOF
6466 }
6467 }()
6468
6469 if maj != cbg.MajMap {
6470 return fmt.Errorf("cbor input should be of type map")
6471 }
6472
6473 if extra > cbg.MaxLength {
6474 return fmt.Errorf("LabelDefinition: map struct too large (%d)", extra)
6475 }
6476
6477 n := extra
6478
6479 nameBuf := make([]byte, 9)
6480 for i := uint64(0); i < n; i++ {
6481 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6482 if err != nil {
6483 return err
6484 }
6485
6486 if !ok {
6487 // Field doesn't exist on this type, so ignore it
6488 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6489 return err
6490 }
6491 continue
6492 }
6493
6494 switch string(nameBuf[:nameLen]) {
6495 // t.Name (string) (string)
6496 case "name":
6497
6498 {
6499 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6500 if err != nil {
6501 return err
6502 }
6503
6504 t.Name = string(sval)
6505 }
6506 // t.LexiconTypeID (string) (string)
6507 case "$type":
6508
6509 {
6510 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6511 if err != nil {
6512 return err
6513 }
6514
6515 t.LexiconTypeID = string(sval)
6516 }
6517 // t.Color (string) (string)
6518 case "color":
6519
6520 {
6521 b, err := cr.ReadByte()
6522 if err != nil {
6523 return err
6524 }
6525 if b != cbg.CborNull[0] {
6526 if err := cr.UnreadByte(); err != nil {
6527 return err
6528 }
6529
6530 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6531 if err != nil {
6532 return err
6533 }
6534
6535 t.Color = (*string)(&sval)
6536 }
6537 }
6538 // t.Scope ([]string) (slice)
6539 case "scope":
6540
6541 maj, extra, err = cr.ReadHeader()
6542 if err != nil {
6543 return err
6544 }
6545
6546 if extra > 8192 {
6547 return fmt.Errorf("t.Scope: array too large (%d)", extra)
6548 }
6549
6550 if maj != cbg.MajArray {
6551 return fmt.Errorf("expected cbor array")
6552 }
6553
6554 if extra > 0 {
6555 t.Scope = make([]string, extra)
6556 }
6557
6558 for i := 0; i < int(extra); i++ {
6559 {
6560 var maj byte
6561 var extra uint64
6562 var err error
6563 _ = maj
6564 _ = extra
6565 _ = err
6566
6567 {
6568 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6569 if err != nil {
6570 return err
6571 }
6572
6573 t.Scope[i] = string(sval)
6574 }
6575
6576 }
6577 }
6578 // t.Multiple (bool) (bool)
6579 case "multiple":
6580
6581 {
6582 b, err := cr.ReadByte()
6583 if err != nil {
6584 return err
6585 }
6586 if b != cbg.CborNull[0] {
6587 if err := cr.UnreadByte(); err != nil {
6588 return err
6589 }
6590
6591 maj, extra, err = cr.ReadHeader()
6592 if err != nil {
6593 return err
6594 }
6595 if maj != cbg.MajOther {
6596 return fmt.Errorf("booleans must be major type 7")
6597 }
6598
6599 var val bool
6600 switch extra {
6601 case 20:
6602 val = false
6603 case 21:
6604 val = true
6605 default:
6606 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
6607 }
6608 t.Multiple = &val
6609 }
6610 }
6611 // t.CreatedAt (string) (string)
6612 case "createdAt":
6613
6614 {
6615 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6616 if err != nil {
6617 return err
6618 }
6619
6620 t.CreatedAt = string(sval)
6621 }
6622 // t.ValueType (tangled.LabelDefinition_ValueType) (struct)
6623 case "valueType":
6624
6625 {
6626
6627 b, err := cr.ReadByte()
6628 if err != nil {
6629 return err
6630 }
6631 if b != cbg.CborNull[0] {
6632 if err := cr.UnreadByte(); err != nil {
6633 return err
6634 }
6635 t.ValueType = new(LabelDefinition_ValueType)
6636 if err := t.ValueType.UnmarshalCBOR(cr); err != nil {
6637 return xerrors.Errorf("unmarshaling t.ValueType pointer: %w", err)
6638 }
6639 }
6640
6641 }
6642
6643 default:
6644 // Field doesn't exist on this type, so ignore it
6645 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6646 return err
6647 }
6648 }
6649 }
6650
6651 return nil
6652}
6653func (t *LabelDefinition_ValueType) MarshalCBOR(w io.Writer) error {
6654 if t == nil {
6655 _, err := w.Write(cbg.CborNull)
6656 return err
6657 }
6658
6659 cw := cbg.NewCborWriter(w)
6660 fieldCount := 3
6661
6662 if t.Enum == nil {
6663 fieldCount--
6664 }
6665
6666 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6667 return err
6668 }
6669
6670 // t.Enum ([]string) (slice)
6671 if t.Enum != nil {
6672
6673 if len("enum") > 1000000 {
6674 return xerrors.Errorf("Value in field \"enum\" was too long")
6675 }
6676
6677 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("enum"))); err != nil {
6678 return err
6679 }
6680 if _, err := cw.WriteString(string("enum")); err != nil {
6681 return err
6682 }
6683
6684 if len(t.Enum) > 8192 {
6685 return xerrors.Errorf("Slice value in field t.Enum was too long")
6686 }
6687
6688 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Enum))); err != nil {
6689 return err
6690 }
6691 for _, v := range t.Enum {
6692 if len(v) > 1000000 {
6693 return xerrors.Errorf("Value in field v was too long")
6694 }
6695
6696 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
6697 return err
6698 }
6699 if _, err := cw.WriteString(string(v)); err != nil {
6700 return err
6701 }
6702
6703 }
6704 }
6705
6706 // t.Type (string) (string)
6707 if len("type") > 1000000 {
6708 return xerrors.Errorf("Value in field \"type\" was too long")
6709 }
6710
6711 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("type"))); err != nil {
6712 return err
6713 }
6714 if _, err := cw.WriteString(string("type")); err != nil {
6715 return err
6716 }
6717
6718 if len(t.Type) > 1000000 {
6719 return xerrors.Errorf("Value in field t.Type was too long")
6720 }
6721
6722 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Type))); err != nil {
6723 return err
6724 }
6725 if _, err := cw.WriteString(string(t.Type)); err != nil {
6726 return err
6727 }
6728
6729 // t.Format (string) (string)
6730 if len("format") > 1000000 {
6731 return xerrors.Errorf("Value in field \"format\" was too long")
6732 }
6733
6734 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("format"))); err != nil {
6735 return err
6736 }
6737 if _, err := cw.WriteString(string("format")); err != nil {
6738 return err
6739 }
6740
6741 if len(t.Format) > 1000000 {
6742 return xerrors.Errorf("Value in field t.Format was too long")
6743 }
6744
6745 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Format))); err != nil {
6746 return err
6747 }
6748 if _, err := cw.WriteString(string(t.Format)); err != nil {
6749 return err
6750 }
6751 return nil
6752}
6753
6754func (t *LabelDefinition_ValueType) UnmarshalCBOR(r io.Reader) (err error) {
6755 *t = LabelDefinition_ValueType{}
6756
6757 cr := cbg.NewCborReader(r)
6758
6759 maj, extra, err := cr.ReadHeader()
6760 if err != nil {
6761 return err
6762 }
6763 defer func() {
6764 if err == io.EOF {
6765 err = io.ErrUnexpectedEOF
6766 }
6767 }()
6768
6769 if maj != cbg.MajMap {
6770 return fmt.Errorf("cbor input should be of type map")
6771 }
6772
6773 if extra > cbg.MaxLength {
6774 return fmt.Errorf("LabelDefinition_ValueType: map struct too large (%d)", extra)
6775 }
6776
6777 n := extra
6778
6779 nameBuf := make([]byte, 6)
6780 for i := uint64(0); i < n; i++ {
6781 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6782 if err != nil {
6783 return err
6784 }
6785
6786 if !ok {
6787 // Field doesn't exist on this type, so ignore it
6788 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6789 return err
6790 }
6791 continue
6792 }
6793
6794 switch string(nameBuf[:nameLen]) {
6795 // t.Enum ([]string) (slice)
6796 case "enum":
6797
6798 maj, extra, err = cr.ReadHeader()
6799 if err != nil {
6800 return err
6801 }
6802
6803 if extra > 8192 {
6804 return fmt.Errorf("t.Enum: array too large (%d)", extra)
6805 }
6806
6807 if maj != cbg.MajArray {
6808 return fmt.Errorf("expected cbor array")
6809 }
6810
6811 if extra > 0 {
6812 t.Enum = make([]string, extra)
6813 }
6814
6815 for i := 0; i < int(extra); i++ {
6816 {
6817 var maj byte
6818 var extra uint64
6819 var err error
6820 _ = maj
6821 _ = extra
6822 _ = err
6823
6824 {
6825 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6826 if err != nil {
6827 return err
6828 }
6829
6830 t.Enum[i] = string(sval)
6831 }
6832
6833 }
6834 }
6835 // t.Type (string) (string)
6836 case "type":
6837
6838 {
6839 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6840 if err != nil {
6841 return err
6842 }
6843
6844 t.Type = string(sval)
6845 }
6846 // t.Format (string) (string)
6847 case "format":
6848
6849 {
6850 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6851 if err != nil {
6852 return err
6853 }
6854
6855 t.Format = string(sval)
6856 }
6857
6858 default:
6859 // Field doesn't exist on this type, so ignore it
6860 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6861 return err
6862 }
6863 }
6864 }
6865
6866 return nil
6867}
6868func (t *LabelOp) MarshalCBOR(w io.Writer) error {
6869 if t == nil {
6870 _, err := w.Write(cbg.CborNull)
6871 return err
6872 }
6873
6874 cw := cbg.NewCborWriter(w)
6875
6876 if _, err := cw.Write([]byte{165}); err != nil {
6877 return err
6878 }
6879
6880 // t.Add ([]*tangled.LabelOp_Operand) (slice)
6881 if len("add") > 1000000 {
6882 return xerrors.Errorf("Value in field \"add\" was too long")
6883 }
6884
6885 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("add"))); err != nil {
6886 return err
6887 }
6888 if _, err := cw.WriteString(string("add")); err != nil {
6889 return err
6890 }
6891
6892 if len(t.Add) > 8192 {
6893 return xerrors.Errorf("Slice value in field t.Add was too long")
6894 }
6895
6896 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Add))); err != nil {
6897 return err
6898 }
6899 for _, v := range t.Add {
6900 if err := v.MarshalCBOR(cw); err != nil {
6901 return err
6902 }
6903
6904 }
6905
6906 // t.LexiconTypeID (string) (string)
6907 if len("$type") > 1000000 {
6908 return xerrors.Errorf("Value in field \"$type\" was too long")
6909 }
6910
6911 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6912 return err
6913 }
6914 if _, err := cw.WriteString(string("$type")); err != nil {
6915 return err
6916 }
6917
6918 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.op"))); err != nil {
6919 return err
6920 }
6921 if _, err := cw.WriteString(string("sh.tangled.label.op")); err != nil {
6922 return err
6923 }
6924
6925 // t.Delete ([]*tangled.LabelOp_Operand) (slice)
6926 if len("delete") > 1000000 {
6927 return xerrors.Errorf("Value in field \"delete\" was too long")
6928 }
6929
6930 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("delete"))); err != nil {
6931 return err
6932 }
6933 if _, err := cw.WriteString(string("delete")); err != nil {
6934 return err
6935 }
6936
6937 if len(t.Delete) > 8192 {
6938 return xerrors.Errorf("Slice value in field t.Delete was too long")
6939 }
6940
6941 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Delete))); err != nil {
6942 return err
6943 }
6944 for _, v := range t.Delete {
6945 if err := v.MarshalCBOR(cw); err != nil {
6946 return err
6947 }
6948
6949 }
6950
6951 // t.Subject (string) (string)
6952 if len("subject") > 1000000 {
6953 return xerrors.Errorf("Value in field \"subject\" was too long")
6954 }
6955
6956 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
6957 return err
6958 }
6959 if _, err := cw.WriteString(string("subject")); err != nil {
6960 return err
6961 }
6962
6963 if len(t.Subject) > 1000000 {
6964 return xerrors.Errorf("Value in field t.Subject was too long")
6965 }
6966
6967 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
6968 return err
6969 }
6970 if _, err := cw.WriteString(string(t.Subject)); err != nil {
6971 return err
6972 }
6973
6974 // t.PerformedAt (string) (string)
6975 if len("performedAt") > 1000000 {
6976 return xerrors.Errorf("Value in field \"performedAt\" was too long")
6977 }
6978
6979 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("performedAt"))); err != nil {
6980 return err
6981 }
6982 if _, err := cw.WriteString(string("performedAt")); err != nil {
6983 return err
6984 }
6985
6986 if len(t.PerformedAt) > 1000000 {
6987 return xerrors.Errorf("Value in field t.PerformedAt was too long")
6988 }
6989
6990 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.PerformedAt))); err != nil {
6991 return err
6992 }
6993 if _, err := cw.WriteString(string(t.PerformedAt)); err != nil {
6994 return err
6995 }
6996 return nil
6997}
6998
6999func (t *LabelOp) UnmarshalCBOR(r io.Reader) (err error) {
7000 *t = LabelOp{}
7001
7002 cr := cbg.NewCborReader(r)
7003
7004 maj, extra, err := cr.ReadHeader()
7005 if err != nil {
7006 return err
7007 }
7008 defer func() {
7009 if err == io.EOF {
7010 err = io.ErrUnexpectedEOF
7011 }
7012 }()
7013
7014 if maj != cbg.MajMap {
7015 return fmt.Errorf("cbor input should be of type map")
7016 }
7017
7018 if extra > cbg.MaxLength {
7019 return fmt.Errorf("LabelOp: map struct too large (%d)", extra)
7020 }
7021
7022 n := extra
7023
7024 nameBuf := make([]byte, 11)
7025 for i := uint64(0); i < n; i++ {
7026 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7027 if err != nil {
7028 return err
7029 }
7030
7031 if !ok {
7032 // Field doesn't exist on this type, so ignore it
7033 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7034 return err
7035 }
7036 continue
7037 }
7038
7039 switch string(nameBuf[:nameLen]) {
7040 // t.Add ([]*tangled.LabelOp_Operand) (slice)
7041 case "add":
7042
7043 maj, extra, err = cr.ReadHeader()
7044 if err != nil {
7045 return err
7046 }
7047
7048 if extra > 8192 {
7049 return fmt.Errorf("t.Add: array too large (%d)", extra)
7050 }
7051
7052 if maj != cbg.MajArray {
7053 return fmt.Errorf("expected cbor array")
7054 }
7055
7056 if extra > 0 {
7057 t.Add = make([]*LabelOp_Operand, extra)
7058 }
7059
7060 for i := 0; i < int(extra); i++ {
7061 {
7062 var maj byte
7063 var extra uint64
7064 var err error
7065 _ = maj
7066 _ = extra
7067 _ = err
7068
7069 {
7070
7071 b, err := cr.ReadByte()
7072 if err != nil {
7073 return err
7074 }
7075 if b != cbg.CborNull[0] {
7076 if err := cr.UnreadByte(); err != nil {
7077 return err
7078 }
7079 t.Add[i] = new(LabelOp_Operand)
7080 if err := t.Add[i].UnmarshalCBOR(cr); err != nil {
7081 return xerrors.Errorf("unmarshaling t.Add[i] pointer: %w", err)
7082 }
7083 }
7084
7085 }
7086
7087 }
7088 }
7089 // t.LexiconTypeID (string) (string)
7090 case "$type":
7091
7092 {
7093 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7094 if err != nil {
7095 return err
7096 }
7097
7098 t.LexiconTypeID = string(sval)
7099 }
7100 // t.Delete ([]*tangled.LabelOp_Operand) (slice)
7101 case "delete":
7102
7103 maj, extra, err = cr.ReadHeader()
7104 if err != nil {
7105 return err
7106 }
7107
7108 if extra > 8192 {
7109 return fmt.Errorf("t.Delete: array too large (%d)", extra)
7110 }
7111
7112 if maj != cbg.MajArray {
7113 return fmt.Errorf("expected cbor array")
7114 }
7115
7116 if extra > 0 {
7117 t.Delete = make([]*LabelOp_Operand, extra)
7118 }
7119
7120 for i := 0; i < int(extra); i++ {
7121 {
7122 var maj byte
7123 var extra uint64
7124 var err error
7125 _ = maj
7126 _ = extra
7127 _ = err
7128
7129 {
7130
7131 b, err := cr.ReadByte()
7132 if err != nil {
7133 return err
7134 }
7135 if b != cbg.CborNull[0] {
7136 if err := cr.UnreadByte(); err != nil {
7137 return err
7138 }
7139 t.Delete[i] = new(LabelOp_Operand)
7140 if err := t.Delete[i].UnmarshalCBOR(cr); err != nil {
7141 return xerrors.Errorf("unmarshaling t.Delete[i] pointer: %w", err)
7142 }
7143 }
7144
7145 }
7146
7147 }
7148 }
7149 // t.Subject (string) (string)
7150 case "subject":
7151
7152 {
7153 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7154 if err != nil {
7155 return err
7156 }
7157
7158 t.Subject = string(sval)
7159 }
7160 // t.PerformedAt (string) (string)
7161 case "performedAt":
7162
7163 {
7164 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7165 if err != nil {
7166 return err
7167 }
7168
7169 t.PerformedAt = string(sval)
7170 }
7171
7172 default:
7173 // Field doesn't exist on this type, so ignore it
7174 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7175 return err
7176 }
7177 }
7178 }
7179
7180 return nil
7181}
7182func (t *LabelOp_Operand) MarshalCBOR(w io.Writer) error {
7183 if t == nil {
7184 _, err := w.Write(cbg.CborNull)
7185 return err
7186 }
7187
7188 cw := cbg.NewCborWriter(w)
7189
7190 if _, err := cw.Write([]byte{162}); err != nil {
7191 return err
7192 }
7193
7194 // t.Key (string) (string)
7195 if len("key") > 1000000 {
7196 return xerrors.Errorf("Value in field \"key\" was too long")
7197 }
7198
7199 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
7200 return err
7201 }
7202 if _, err := cw.WriteString(string("key")); err != nil {
7203 return err
7204 }
7205
7206 if len(t.Key) > 1000000 {
7207 return xerrors.Errorf("Value in field t.Key was too long")
7208 }
7209
7210 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
7211 return err
7212 }
7213 if _, err := cw.WriteString(string(t.Key)); err != nil {
7214 return err
7215 }
7216
7217 // t.Value (string) (string)
7218 if len("value") > 1000000 {
7219 return xerrors.Errorf("Value in field \"value\" was too long")
7220 }
7221
7222 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
7223 return err
7224 }
7225 if _, err := cw.WriteString(string("value")); err != nil {
7226 return err
7227 }
7228
7229 if len(t.Value) > 1000000 {
7230 return xerrors.Errorf("Value in field t.Value was too long")
7231 }
7232
7233 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
7234 return err
7235 }
7236 if _, err := cw.WriteString(string(t.Value)); err != nil {
7237 return err
7238 }
7239 return nil
7240}
7241
7242func (t *LabelOp_Operand) UnmarshalCBOR(r io.Reader) (err error) {
7243 *t = LabelOp_Operand{}
7244
7245 cr := cbg.NewCborReader(r)
7246
7247 maj, extra, err := cr.ReadHeader()
7248 if err != nil {
7249 return err
7250 }
7251 defer func() {
7252 if err == io.EOF {
7253 err = io.ErrUnexpectedEOF
7254 }
7255 }()
7256
7257 if maj != cbg.MajMap {
7258 return fmt.Errorf("cbor input should be of type map")
7259 }
7260
7261 if extra > cbg.MaxLength {
7262 return fmt.Errorf("LabelOp_Operand: map struct too large (%d)", extra)
7263 }
7264
7265 n := extra
7266
7267 nameBuf := make([]byte, 5)
7268 for i := uint64(0); i < n; i++ {
7269 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7270 if err != nil {
7271 return err
7272 }
7273
7274 if !ok {
7275 // Field doesn't exist on this type, so ignore it
7276 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7277 return err
7278 }
7279 continue
7280 }
7281
7282 switch string(nameBuf[:nameLen]) {
7283 // t.Key (string) (string)
7284 case "key":
7285
7286 {
7287 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7288 if err != nil {
7289 return err
7290 }
7291
7292 t.Key = string(sval)
7293 }
7294 // t.Value (string) (string)
7295 case "value":
7296
7297 {
7298 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7299 if err != nil {
7300 return err
7301 }
7302
7303 t.Value = string(sval)
7304 }
7305
7306 default:
7307 // Field doesn't exist on this type, so ignore it
7308 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7309 return err
7310 }
7311 }
7312 }
7313
7314 return nil
7315}
7316func (t *MarkupMarkdown) MarshalCBOR(w io.Writer) error {
7317 if t == nil {
7318 _, err := w.Write(cbg.CborNull)
7319 return err
7320 }
7321
7322 cw := cbg.NewCborWriter(w)
7323 fieldCount := 4
7324
7325 if t.Blobs == nil {
7326 fieldCount--
7327 }
7328
7329 if t.Original == nil {
7330 fieldCount--
7331 }
7332
7333 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7334 return err
7335 }
7336
7337 // t.Text (string) (string)
7338 if len("text") > 1000000 {
7339 return xerrors.Errorf("Value in field \"text\" was too long")
7340 }
7341
7342 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("text"))); err != nil {
7343 return err
7344 }
7345 if _, err := cw.WriteString(string("text")); err != nil {
7346 return err
7347 }
7348
7349 if len(t.Text) > 1000000 {
7350 return xerrors.Errorf("Value in field t.Text was too long")
7351 }
7352
7353 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Text))); err != nil {
7354 return err
7355 }
7356 if _, err := cw.WriteString(string(t.Text)); err != nil {
7357 return err
7358 }
7359
7360 // t.LexiconTypeID (string) (string)
7361 if len("$type") > 1000000 {
7362 return xerrors.Errorf("Value in field \"$type\" was too long")
7363 }
7364
7365 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7366 return err
7367 }
7368 if _, err := cw.WriteString(string("$type")); err != nil {
7369 return err
7370 }
7371
7372 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.markup.markdown"))); err != nil {
7373 return err
7374 }
7375 if _, err := cw.WriteString(string("sh.tangled.markup.markdown")); err != nil {
7376 return err
7377 }
7378
7379 // t.Blobs ([]*util.LexBlob) (slice)
7380 if t.Blobs != nil {
7381
7382 if len("blobs") > 1000000 {
7383 return xerrors.Errorf("Value in field \"blobs\" was too long")
7384 }
7385
7386 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("blobs"))); err != nil {
7387 return err
7388 }
7389 if _, err := cw.WriteString(string("blobs")); err != nil {
7390 return err
7391 }
7392
7393 if len(t.Blobs) > 8192 {
7394 return xerrors.Errorf("Slice value in field t.Blobs was too long")
7395 }
7396
7397 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Blobs))); err != nil {
7398 return err
7399 }
7400 for _, v := range t.Blobs {
7401 if err := v.MarshalCBOR(cw); err != nil {
7402 return err
7403 }
7404
7405 }
7406 }
7407
7408 // t.Original (string) (string)
7409 if t.Original != nil {
7410
7411 if len("original") > 1000000 {
7412 return xerrors.Errorf("Value in field \"original\" was too long")
7413 }
7414
7415 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("original"))); err != nil {
7416 return err
7417 }
7418 if _, err := cw.WriteString(string("original")); err != nil {
7419 return err
7420 }
7421
7422 if t.Original == nil {
7423 if _, err := cw.Write(cbg.CborNull); err != nil {
7424 return err
7425 }
7426 } else {
7427 if len(*t.Original) > 1000000 {
7428 return xerrors.Errorf("Value in field t.Original was too long")
7429 }
7430
7431 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Original))); err != nil {
7432 return err
7433 }
7434 if _, err := cw.WriteString(string(*t.Original)); err != nil {
7435 return err
7436 }
7437 }
7438 }
7439 return nil
7440}
7441
7442func (t *MarkupMarkdown) UnmarshalCBOR(r io.Reader) (err error) {
7443 *t = MarkupMarkdown{}
7444
7445 cr := cbg.NewCborReader(r)
7446
7447 maj, extra, err := cr.ReadHeader()
7448 if err != nil {
7449 return err
7450 }
7451 defer func() {
7452 if err == io.EOF {
7453 err = io.ErrUnexpectedEOF
7454 }
7455 }()
7456
7457 if maj != cbg.MajMap {
7458 return fmt.Errorf("cbor input should be of type map")
7459 }
7460
7461 if extra > cbg.MaxLength {
7462 return fmt.Errorf("MarkupMarkdown: map struct too large (%d)", extra)
7463 }
7464
7465 n := extra
7466
7467 nameBuf := make([]byte, 8)
7468 for i := uint64(0); i < n; i++ {
7469 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7470 if err != nil {
7471 return err
7472 }
7473
7474 if !ok {
7475 // Field doesn't exist on this type, so ignore it
7476 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7477 return err
7478 }
7479 continue
7480 }
7481
7482 switch string(nameBuf[:nameLen]) {
7483 // t.Text (string) (string)
7484 case "text":
7485
7486 {
7487 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7488 if err != nil {
7489 return err
7490 }
7491
7492 t.Text = string(sval)
7493 }
7494 // t.LexiconTypeID (string) (string)
7495 case "$type":
7496
7497 {
7498 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7499 if err != nil {
7500 return err
7501 }
7502
7503 t.LexiconTypeID = string(sval)
7504 }
7505 // t.Blobs ([]*util.LexBlob) (slice)
7506 case "blobs":
7507
7508 maj, extra, err = cr.ReadHeader()
7509 if err != nil {
7510 return err
7511 }
7512
7513 if extra > 8192 {
7514 return fmt.Errorf("t.Blobs: array too large (%d)", extra)
7515 }
7516
7517 if maj != cbg.MajArray {
7518 return fmt.Errorf("expected cbor array")
7519 }
7520
7521 if extra > 0 {
7522 t.Blobs = make([]*util.LexBlob, extra)
7523 }
7524
7525 for i := 0; i < int(extra); i++ {
7526 {
7527 var maj byte
7528 var extra uint64
7529 var err error
7530 _ = maj
7531 _ = extra
7532 _ = err
7533
7534 {
7535
7536 b, err := cr.ReadByte()
7537 if err != nil {
7538 return err
7539 }
7540 if b != cbg.CborNull[0] {
7541 if err := cr.UnreadByte(); err != nil {
7542 return err
7543 }
7544 t.Blobs[i] = new(util.LexBlob)
7545 if err := t.Blobs[i].UnmarshalCBOR(cr); err != nil {
7546 return xerrors.Errorf("unmarshaling t.Blobs[i] pointer: %w", err)
7547 }
7548 }
7549
7550 }
7551
7552 }
7553 }
7554 // t.Original (string) (string)
7555 case "original":
7556
7557 {
7558 b, err := cr.ReadByte()
7559 if err != nil {
7560 return err
7561 }
7562 if b != cbg.CborNull[0] {
7563 if err := cr.UnreadByte(); err != nil {
7564 return err
7565 }
7566
7567 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7568 if err != nil {
7569 return err
7570 }
7571
7572 t.Original = (*string)(&sval)
7573 }
7574 }
7575
7576 default:
7577 // Field doesn't exist on this type, so ignore it
7578 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7579 return err
7580 }
7581 }
7582 }
7583
7584 return nil
7585}
7586func (t *Pipeline) MarshalCBOR(w io.Writer) error {
7587 if t == nil {
7588 _, err := w.Write(cbg.CborNull)
7589 return err
7590 }
7591
7592 cw := cbg.NewCborWriter(w)
7593
7594 if _, err := cw.Write([]byte{163}); err != nil {
7595 return err
7596 }
7597
7598 // t.LexiconTypeID (string) (string)
7599 if len("$type") > 1000000 {
7600 return xerrors.Errorf("Value in field \"$type\" was too long")
7601 }
7602
7603 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7604 return err
7605 }
7606 if _, err := cw.WriteString(string("$type")); err != nil {
7607 return err
7608 }
7609
7610 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil {
7611 return err
7612 }
7613 if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil {
7614 return err
7615 }
7616
7617 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
7618 if len("workflows") > 1000000 {
7619 return xerrors.Errorf("Value in field \"workflows\" was too long")
7620 }
7621
7622 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil {
7623 return err
7624 }
7625 if _, err := cw.WriteString(string("workflows")); err != nil {
7626 return err
7627 }
7628
7629 if len(t.Workflows) > 8192 {
7630 return xerrors.Errorf("Slice value in field t.Workflows was too long")
7631 }
7632
7633 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil {
7634 return err
7635 }
7636 for _, v := range t.Workflows {
7637 if err := v.MarshalCBOR(cw); err != nil {
7638 return err
7639 }
7640
7641 }
7642
7643 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
7644 if len("triggerMetadata") > 1000000 {
7645 return xerrors.Errorf("Value in field \"triggerMetadata\" was too long")
7646 }
7647
7648 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil {
7649 return err
7650 }
7651 if _, err := cw.WriteString(string("triggerMetadata")); err != nil {
7652 return err
7653 }
7654
7655 if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil {
7656 return err
7657 }
7658 return nil
7659}
7660
7661func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) {
7662 *t = Pipeline{}
7663
7664 cr := cbg.NewCborReader(r)
7665
7666 maj, extra, err := cr.ReadHeader()
7667 if err != nil {
7668 return err
7669 }
7670 defer func() {
7671 if err == io.EOF {
7672 err = io.ErrUnexpectedEOF
7673 }
7674 }()
7675
7676 if maj != cbg.MajMap {
7677 return fmt.Errorf("cbor input should be of type map")
7678 }
7679
7680 if extra > cbg.MaxLength {
7681 return fmt.Errorf("Pipeline: map struct too large (%d)", extra)
7682 }
7683
7684 n := extra
7685
7686 nameBuf := make([]byte, 15)
7687 for i := uint64(0); i < n; i++ {
7688 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7689 if err != nil {
7690 return err
7691 }
7692
7693 if !ok {
7694 // Field doesn't exist on this type, so ignore it
7695 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7696 return err
7697 }
7698 continue
7699 }
7700
7701 switch string(nameBuf[:nameLen]) {
7702 // t.LexiconTypeID (string) (string)
7703 case "$type":
7704
7705 {
7706 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7707 if err != nil {
7708 return err
7709 }
7710
7711 t.LexiconTypeID = string(sval)
7712 }
7713 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
7714 case "workflows":
7715
7716 maj, extra, err = cr.ReadHeader()
7717 if err != nil {
7718 return err
7719 }
7720
7721 if extra > 8192 {
7722 return fmt.Errorf("t.Workflows: array too large (%d)", extra)
7723 }
7724
7725 if maj != cbg.MajArray {
7726 return fmt.Errorf("expected cbor array")
7727 }
7728
7729 if extra > 0 {
7730 t.Workflows = make([]*Pipeline_Workflow, extra)
7731 }
7732
7733 for i := 0; i < int(extra); i++ {
7734 {
7735 var maj byte
7736 var extra uint64
7737 var err error
7738 _ = maj
7739 _ = extra
7740 _ = err
7741
7742 {
7743
7744 b, err := cr.ReadByte()
7745 if err != nil {
7746 return err
7747 }
7748 if b != cbg.CborNull[0] {
7749 if err := cr.UnreadByte(); err != nil {
7750 return err
7751 }
7752 t.Workflows[i] = new(Pipeline_Workflow)
7753 if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil {
7754 return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err)
7755 }
7756 }
7757
7758 }
7759
7760 }
7761 }
7762 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
7763 case "triggerMetadata":
7764
7765 {
7766
7767 b, err := cr.ReadByte()
7768 if err != nil {
7769 return err
7770 }
7771 if b != cbg.CborNull[0] {
7772 if err := cr.UnreadByte(); err != nil {
7773 return err
7774 }
7775 t.TriggerMetadata = new(Pipeline_TriggerMetadata)
7776 if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil {
7777 return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err)
7778 }
7779 }
7780
7781 }
7782
7783 default:
7784 // Field doesn't exist on this type, so ignore it
7785 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7786 return err
7787 }
7788 }
7789 }
7790
7791 return nil
7792}
7793func (t *Pipeline_CloneOpts) MarshalCBOR(w io.Writer) error {
7794 if t == nil {
7795 _, err := w.Write(cbg.CborNull)
7796 return err
7797 }
7798
7799 cw := cbg.NewCborWriter(w)
7800
7801 if _, err := cw.Write([]byte{164}); err != nil {
7802 return err
7803 }
7804
7805 // t.Skip (bool) (bool)
7806 if len("skip") > 1000000 {
7807 return xerrors.Errorf("Value in field \"skip\" was too long")
7808 }
7809
7810 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("skip"))); err != nil {
7811 return err
7812 }
7813 if _, err := cw.WriteString(string("skip")); err != nil {
7814 return err
7815 }
7816
7817 if err := cbg.WriteBool(w, t.Skip); err != nil {
7818 return err
7819 }
7820
7821 // t.Tags (bool) (bool)
7822 if len("tags") > 1000000 {
7823 return xerrors.Errorf("Value in field \"tags\" was too long")
7824 }
7825
7826 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tags"))); err != nil {
7827 return err
7828 }
7829 if _, err := cw.WriteString(string("tags")); err != nil {
7830 return err
7831 }
7832
7833 if err := cbg.WriteBool(w, t.Tags); err != nil {
7834 return err
7835 }
7836
7837 // t.Depth (int64) (int64)
7838 if len("depth") > 1000000 {
7839 return xerrors.Errorf("Value in field \"depth\" was too long")
7840 }
7841
7842 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("depth"))); err != nil {
7843 return err
7844 }
7845 if _, err := cw.WriteString(string("depth")); err != nil {
7846 return err
7847 }
7848
7849 if t.Depth >= 0 {
7850 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Depth)); err != nil {
7851 return err
7852 }
7853 } else {
7854 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Depth-1)); err != nil {
7855 return err
7856 }
7857 }
7858
7859 // t.Submodules (bool) (bool)
7860 if len("submodules") > 1000000 {
7861 return xerrors.Errorf("Value in field \"submodules\" was too long")
7862 }
7863
7864 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("submodules"))); err != nil {
7865 return err
7866 }
7867 if _, err := cw.WriteString(string("submodules")); err != nil {
7868 return err
7869 }
7870
7871 if err := cbg.WriteBool(w, t.Submodules); err != nil {
7872 return err
7873 }
7874 return nil
7875}
7876
7877func (t *Pipeline_CloneOpts) UnmarshalCBOR(r io.Reader) (err error) {
7878 *t = Pipeline_CloneOpts{}
7879
7880 cr := cbg.NewCborReader(r)
7881
7882 maj, extra, err := cr.ReadHeader()
7883 if err != nil {
7884 return err
7885 }
7886 defer func() {
7887 if err == io.EOF {
7888 err = io.ErrUnexpectedEOF
7889 }
7890 }()
7891
7892 if maj != cbg.MajMap {
7893 return fmt.Errorf("cbor input should be of type map")
7894 }
7895
7896 if extra > cbg.MaxLength {
7897 return fmt.Errorf("Pipeline_CloneOpts: map struct too large (%d)", extra)
7898 }
7899
7900 n := extra
7901
7902 nameBuf := make([]byte, 10)
7903 for i := uint64(0); i < n; i++ {
7904 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7905 if err != nil {
7906 return err
7907 }
7908
7909 if !ok {
7910 // Field doesn't exist on this type, so ignore it
7911 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7912 return err
7913 }
7914 continue
7915 }
7916
7917 switch string(nameBuf[:nameLen]) {
7918 // t.Skip (bool) (bool)
7919 case "skip":
7920
7921 maj, extra, err = cr.ReadHeader()
7922 if err != nil {
7923 return err
7924 }
7925 if maj != cbg.MajOther {
7926 return fmt.Errorf("booleans must be major type 7")
7927 }
7928 switch extra {
7929 case 20:
7930 t.Skip = false
7931 case 21:
7932 t.Skip = true
7933 default:
7934 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
7935 }
7936 // t.Tags (bool) (bool)
7937 case "tags":
7938
7939 maj, extra, err = cr.ReadHeader()
7940 if err != nil {
7941 return err
7942 }
7943 if maj != cbg.MajOther {
7944 return fmt.Errorf("booleans must be major type 7")
7945 }
7946 switch extra {
7947 case 20:
7948 t.Tags = false
7949 case 21:
7950 t.Tags = true
7951 default:
7952 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
7953 }
7954 // t.Depth (int64) (int64)
7955 case "depth":
7956 {
7957 maj, extra, err := cr.ReadHeader()
7958 if err != nil {
7959 return err
7960 }
7961 var extraI int64
7962 switch maj {
7963 case cbg.MajUnsignedInt:
7964 extraI = int64(extra)
7965 if extraI < 0 {
7966 return fmt.Errorf("int64 positive overflow")
7967 }
7968 case cbg.MajNegativeInt:
7969 extraI = int64(extra)
7970 if extraI < 0 {
7971 return fmt.Errorf("int64 negative overflow")
7972 }
7973 extraI = -1 - extraI
7974 default:
7975 return fmt.Errorf("wrong type for int64 field: %d", maj)
7976 }
7977
7978 t.Depth = int64(extraI)
7979 }
7980 // t.Submodules (bool) (bool)
7981 case "submodules":
7982
7983 maj, extra, err = cr.ReadHeader()
7984 if err != nil {
7985 return err
7986 }
7987 if maj != cbg.MajOther {
7988 return fmt.Errorf("booleans must be major type 7")
7989 }
7990 switch extra {
7991 case 20:
7992 t.Submodules = false
7993 case 21:
7994 t.Submodules = true
7995 default:
7996 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
7997 }
7998
7999 default:
8000 // Field doesn't exist on this type, so ignore it
8001 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8002 return err
8003 }
8004 }
8005 }
8006
8007 return nil
8008}
8009func (t *Pipeline_ManualTriggerData) MarshalCBOR(w io.Writer) error {
8010 if t == nil {
8011 _, err := w.Write(cbg.CborNull)
8012 return err
8013 }
8014
8015 cw := cbg.NewCborWriter(w)
8016 fieldCount := 3
8017
8018 if t.Inputs == nil {
8019 fieldCount--
8020 }
8021
8022 if t.Ref == nil {
8023 fieldCount--
8024 }
8025
8026 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
8027 return err
8028 }
8029
8030 // t.Ref (string) (string)
8031 if t.Ref != nil {
8032
8033 if len("ref") > 1000000 {
8034 return xerrors.Errorf("Value in field \"ref\" was too long")
8035 }
8036
8037 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
8038 return err
8039 }
8040 if _, err := cw.WriteString(string("ref")); err != nil {
8041 return err
8042 }
8043
8044 if t.Ref == nil {
8045 if _, err := cw.Write(cbg.CborNull); err != nil {
8046 return err
8047 }
8048 } else {
8049 if len(*t.Ref) > 1000000 {
8050 return xerrors.Errorf("Value in field t.Ref was too long")
8051 }
8052
8053 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Ref))); err != nil {
8054 return err
8055 }
8056 if _, err := cw.WriteString(string(*t.Ref)); err != nil {
8057 return err
8058 }
8059 }
8060 }
8061
8062 // t.Sha (string) (string)
8063 if len("sha") > 1000000 {
8064 return xerrors.Errorf("Value in field \"sha\" was too long")
8065 }
8066
8067 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sha"))); err != nil {
8068 return err
8069 }
8070 if _, err := cw.WriteString(string("sha")); err != nil {
8071 return err
8072 }
8073
8074 if len(t.Sha) > 1000000 {
8075 return xerrors.Errorf("Value in field t.Sha was too long")
8076 }
8077
8078 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Sha))); err != nil {
8079 return err
8080 }
8081 if _, err := cw.WriteString(string(t.Sha)); err != nil {
8082 return err
8083 }
8084
8085 // t.Inputs ([]*tangled.Pipeline_Pair) (slice)
8086 if t.Inputs != nil {
8087
8088 if len("inputs") > 1000000 {
8089 return xerrors.Errorf("Value in field \"inputs\" was too long")
8090 }
8091
8092 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
8093 return err
8094 }
8095 if _, err := cw.WriteString(string("inputs")); err != nil {
8096 return err
8097 }
8098
8099 if len(t.Inputs) > 8192 {
8100 return xerrors.Errorf("Slice value in field t.Inputs was too long")
8101 }
8102
8103 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
8104 return err
8105 }
8106 for _, v := range t.Inputs {
8107 if err := v.MarshalCBOR(cw); err != nil {
8108 return err
8109 }
8110
8111 }
8112 }
8113 return nil
8114}
8115
8116func (t *Pipeline_ManualTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
8117 *t = Pipeline_ManualTriggerData{}
8118
8119 cr := cbg.NewCborReader(r)
8120
8121 maj, extra, err := cr.ReadHeader()
8122 if err != nil {
8123 return err
8124 }
8125 defer func() {
8126 if err == io.EOF {
8127 err = io.ErrUnexpectedEOF
8128 }
8129 }()
8130
8131 if maj != cbg.MajMap {
8132 return fmt.Errorf("cbor input should be of type map")
8133 }
8134
8135 if extra > cbg.MaxLength {
8136 return fmt.Errorf("Pipeline_ManualTriggerData: map struct too large (%d)", extra)
8137 }
8138
8139 n := extra
8140
8141 nameBuf := make([]byte, 6)
8142 for i := uint64(0); i < n; i++ {
8143 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8144 if err != nil {
8145 return err
8146 }
8147
8148 if !ok {
8149 // Field doesn't exist on this type, so ignore it
8150 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8151 return err
8152 }
8153 continue
8154 }
8155
8156 switch string(nameBuf[:nameLen]) {
8157 // t.Ref (string) (string)
8158 case "ref":
8159
8160 {
8161 b, err := cr.ReadByte()
8162 if err != nil {
8163 return err
8164 }
8165 if b != cbg.CborNull[0] {
8166 if err := cr.UnreadByte(); err != nil {
8167 return err
8168 }
8169
8170 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8171 if err != nil {
8172 return err
8173 }
8174
8175 t.Ref = (*string)(&sval)
8176 }
8177 }
8178 // t.Sha (string) (string)
8179 case "sha":
8180
8181 {
8182 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8183 if err != nil {
8184 return err
8185 }
8186
8187 t.Sha = string(sval)
8188 }
8189 // t.Inputs ([]*tangled.Pipeline_Pair) (slice)
8190 case "inputs":
8191
8192 maj, extra, err = cr.ReadHeader()
8193 if err != nil {
8194 return err
8195 }
8196
8197 if extra > 8192 {
8198 return fmt.Errorf("t.Inputs: array too large (%d)", extra)
8199 }
8200
8201 if maj != cbg.MajArray {
8202 return fmt.Errorf("expected cbor array")
8203 }
8204
8205 if extra > 0 {
8206 t.Inputs = make([]*Pipeline_Pair, extra)
8207 }
8208
8209 for i := 0; i < int(extra); i++ {
8210 {
8211 var maj byte
8212 var extra uint64
8213 var err error
8214 _ = maj
8215 _ = extra
8216 _ = err
8217
8218 {
8219
8220 b, err := cr.ReadByte()
8221 if err != nil {
8222 return err
8223 }
8224 if b != cbg.CborNull[0] {
8225 if err := cr.UnreadByte(); err != nil {
8226 return err
8227 }
8228 t.Inputs[i] = new(Pipeline_Pair)
8229 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
8230 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
8231 }
8232 }
8233
8234 }
8235
8236 }
8237 }
8238
8239 default:
8240 // Field doesn't exist on this type, so ignore it
8241 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8242 return err
8243 }
8244 }
8245 }
8246
8247 return nil
8248}
8249func (t *Pipeline_Pair) MarshalCBOR(w io.Writer) error {
8250 if t == nil {
8251 _, err := w.Write(cbg.CborNull)
8252 return err
8253 }
8254
8255 cw := cbg.NewCborWriter(w)
8256
8257 if _, err := cw.Write([]byte{162}); err != nil {
8258 return err
8259 }
8260
8261 // t.Key (string) (string)
8262 if len("key") > 1000000 {
8263 return xerrors.Errorf("Value in field \"key\" was too long")
8264 }
8265
8266 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
8267 return err
8268 }
8269 if _, err := cw.WriteString(string("key")); err != nil {
8270 return err
8271 }
8272
8273 if len(t.Key) > 1000000 {
8274 return xerrors.Errorf("Value in field t.Key was too long")
8275 }
8276
8277 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
8278 return err
8279 }
8280 if _, err := cw.WriteString(string(t.Key)); err != nil {
8281 return err
8282 }
8283
8284 // t.Value (string) (string)
8285 if len("value") > 1000000 {
8286 return xerrors.Errorf("Value in field \"value\" was too long")
8287 }
8288
8289 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
8290 return err
8291 }
8292 if _, err := cw.WriteString(string("value")); err != nil {
8293 return err
8294 }
8295
8296 if len(t.Value) > 1000000 {
8297 return xerrors.Errorf("Value in field t.Value was too long")
8298 }
8299
8300 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
8301 return err
8302 }
8303 if _, err := cw.WriteString(string(t.Value)); err != nil {
8304 return err
8305 }
8306 return nil
8307}
8308
8309func (t *Pipeline_Pair) UnmarshalCBOR(r io.Reader) (err error) {
8310 *t = Pipeline_Pair{}
8311
8312 cr := cbg.NewCborReader(r)
8313
8314 maj, extra, err := cr.ReadHeader()
8315 if err != nil {
8316 return err
8317 }
8318 defer func() {
8319 if err == io.EOF {
8320 err = io.ErrUnexpectedEOF
8321 }
8322 }()
8323
8324 if maj != cbg.MajMap {
8325 return fmt.Errorf("cbor input should be of type map")
8326 }
8327
8328 if extra > cbg.MaxLength {
8329 return fmt.Errorf("Pipeline_Pair: map struct too large (%d)", extra)
8330 }
8331
8332 n := extra
8333
8334 nameBuf := make([]byte, 5)
8335 for i := uint64(0); i < n; i++ {
8336 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8337 if err != nil {
8338 return err
8339 }
8340
8341 if !ok {
8342 // Field doesn't exist on this type, so ignore it
8343 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8344 return err
8345 }
8346 continue
8347 }
8348
8349 switch string(nameBuf[:nameLen]) {
8350 // t.Key (string) (string)
8351 case "key":
8352
8353 {
8354 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8355 if err != nil {
8356 return err
8357 }
8358
8359 t.Key = string(sval)
8360 }
8361 // t.Value (string) (string)
8362 case "value":
8363
8364 {
8365 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8366 if err != nil {
8367 return err
8368 }
8369
8370 t.Value = string(sval)
8371 }
8372
8373 default:
8374 // Field doesn't exist on this type, so ignore it
8375 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8376 return err
8377 }
8378 }
8379 }
8380
8381 return nil
8382}
8383func (t *Pipeline_PullRequestTriggerData) MarshalCBOR(w io.Writer) error {
8384 if t == nil {
8385 _, err := w.Write(cbg.CborNull)
8386 return err
8387 }
8388
8389 cw := cbg.NewCborWriter(w)
8390 fieldCount := 4
8391
8392 if t.Pull == nil {
8393 fieldCount--
8394 }
8395
8396 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
8397 return err
8398 }
8399
8400 // t.Pull (string) (string)
8401 if t.Pull != nil {
8402
8403 if len("pull") > 1000000 {
8404 return xerrors.Errorf("Value in field \"pull\" was too long")
8405 }
8406
8407 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
8408 return err
8409 }
8410 if _, err := cw.WriteString(string("pull")); err != nil {
8411 return err
8412 }
8413
8414 if t.Pull == nil {
8415 if _, err := cw.Write(cbg.CborNull); err != nil {
8416 return err
8417 }
8418 } else {
8419 if len(*t.Pull) > 1000000 {
8420 return xerrors.Errorf("Value in field t.Pull was too long")
8421 }
8422
8423 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Pull))); err != nil {
8424 return err
8425 }
8426 if _, err := cw.WriteString(string(*t.Pull)); err != nil {
8427 return err
8428 }
8429 }
8430 }
8431
8432 // t.SourceSha (string) (string)
8433 if len("sourceSha") > 1000000 {
8434 return xerrors.Errorf("Value in field \"sourceSha\" was too long")
8435 }
8436
8437 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceSha"))); err != nil {
8438 return err
8439 }
8440 if _, err := cw.WriteString(string("sourceSha")); err != nil {
8441 return err
8442 }
8443
8444 if len(t.SourceSha) > 1000000 {
8445 return xerrors.Errorf("Value in field t.SourceSha was too long")
8446 }
8447
8448 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceSha))); err != nil {
8449 return err
8450 }
8451 if _, err := cw.WriteString(string(t.SourceSha)); err != nil {
8452 return err
8453 }
8454
8455 // t.SourceBranch (string) (string)
8456 if len("sourceBranch") > 1000000 {
8457 return xerrors.Errorf("Value in field \"sourceBranch\" was too long")
8458 }
8459
8460 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceBranch"))); err != nil {
8461 return err
8462 }
8463 if _, err := cw.WriteString(string("sourceBranch")); err != nil {
8464 return err
8465 }
8466
8467 if len(t.SourceBranch) > 1000000 {
8468 return xerrors.Errorf("Value in field t.SourceBranch was too long")
8469 }
8470
8471 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceBranch))); err != nil {
8472 return err
8473 }
8474 if _, err := cw.WriteString(string(t.SourceBranch)); err != nil {
8475 return err
8476 }
8477
8478 // t.TargetBranch (string) (string)
8479 if len("targetBranch") > 1000000 {
8480 return xerrors.Errorf("Value in field \"targetBranch\" was too long")
8481 }
8482
8483 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil {
8484 return err
8485 }
8486 if _, err := cw.WriteString(string("targetBranch")); err != nil {
8487 return err
8488 }
8489
8490 if len(t.TargetBranch) > 1000000 {
8491 return xerrors.Errorf("Value in field t.TargetBranch was too long")
8492 }
8493
8494 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil {
8495 return err
8496 }
8497 if _, err := cw.WriteString(string(t.TargetBranch)); err != nil {
8498 return err
8499 }
8500 return nil
8501}
8502
8503func (t *Pipeline_PullRequestTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
8504 *t = Pipeline_PullRequestTriggerData{}
8505
8506 cr := cbg.NewCborReader(r)
8507
8508 maj, extra, err := cr.ReadHeader()
8509 if err != nil {
8510 return err
8511 }
8512 defer func() {
8513 if err == io.EOF {
8514 err = io.ErrUnexpectedEOF
8515 }
8516 }()
8517
8518 if maj != cbg.MajMap {
8519 return fmt.Errorf("cbor input should be of type map")
8520 }
8521
8522 if extra > cbg.MaxLength {
8523 return fmt.Errorf("Pipeline_PullRequestTriggerData: map struct too large (%d)", extra)
8524 }
8525
8526 n := extra
8527
8528 nameBuf := make([]byte, 12)
8529 for i := uint64(0); i < n; i++ {
8530 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8531 if err != nil {
8532 return err
8533 }
8534
8535 if !ok {
8536 // Field doesn't exist on this type, so ignore it
8537 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8538 return err
8539 }
8540 continue
8541 }
8542
8543 switch string(nameBuf[:nameLen]) {
8544 // t.Pull (string) (string)
8545 case "pull":
8546
8547 {
8548 b, err := cr.ReadByte()
8549 if err != nil {
8550 return err
8551 }
8552 if b != cbg.CborNull[0] {
8553 if err := cr.UnreadByte(); err != nil {
8554 return err
8555 }
8556
8557 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8558 if err != nil {
8559 return err
8560 }
8561
8562 t.Pull = (*string)(&sval)
8563 }
8564 }
8565 // t.SourceSha (string) (string)
8566 case "sourceSha":
8567
8568 {
8569 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8570 if err != nil {
8571 return err
8572 }
8573
8574 t.SourceSha = string(sval)
8575 }
8576 // t.SourceBranch (string) (string)
8577 case "sourceBranch":
8578
8579 {
8580 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8581 if err != nil {
8582 return err
8583 }
8584
8585 t.SourceBranch = string(sval)
8586 }
8587 // t.TargetBranch (string) (string)
8588 case "targetBranch":
8589
8590 {
8591 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8592 if err != nil {
8593 return err
8594 }
8595
8596 t.TargetBranch = string(sval)
8597 }
8598
8599 default:
8600 // Field doesn't exist on this type, so ignore it
8601 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8602 return err
8603 }
8604 }
8605 }
8606
8607 return nil
8608}
8609func (t *Pipeline_PushTriggerData) MarshalCBOR(w io.Writer) error {
8610 if t == nil {
8611 _, err := w.Write(cbg.CborNull)
8612 return err
8613 }
8614
8615 cw := cbg.NewCborWriter(w)
8616
8617 if _, err := cw.Write([]byte{163}); err != nil {
8618 return err
8619 }
8620
8621 // t.Ref (string) (string)
8622 if len("ref") > 1000000 {
8623 return xerrors.Errorf("Value in field \"ref\" was too long")
8624 }
8625
8626 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
8627 return err
8628 }
8629 if _, err := cw.WriteString(string("ref")); err != nil {
8630 return err
8631 }
8632
8633 if len(t.Ref) > 1000000 {
8634 return xerrors.Errorf("Value in field t.Ref was too long")
8635 }
8636
8637 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
8638 return err
8639 }
8640 if _, err := cw.WriteString(string(t.Ref)); err != nil {
8641 return err
8642 }
8643
8644 // t.NewSha (string) (string)
8645 if len("newSha") > 1000000 {
8646 return xerrors.Errorf("Value in field \"newSha\" was too long")
8647 }
8648
8649 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
8650 return err
8651 }
8652 if _, err := cw.WriteString(string("newSha")); err != nil {
8653 return err
8654 }
8655
8656 if len(t.NewSha) > 1000000 {
8657 return xerrors.Errorf("Value in field t.NewSha was too long")
8658 }
8659
8660 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
8661 return err
8662 }
8663 if _, err := cw.WriteString(string(t.NewSha)); err != nil {
8664 return err
8665 }
8666
8667 // t.OldSha (string) (string)
8668 if len("oldSha") > 1000000 {
8669 return xerrors.Errorf("Value in field \"oldSha\" was too long")
8670 }
8671
8672 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
8673 return err
8674 }
8675 if _, err := cw.WriteString(string("oldSha")); err != nil {
8676 return err
8677 }
8678
8679 if len(t.OldSha) > 1000000 {
8680 return xerrors.Errorf("Value in field t.OldSha was too long")
8681 }
8682
8683 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
8684 return err
8685 }
8686 if _, err := cw.WriteString(string(t.OldSha)); err != nil {
8687 return err
8688 }
8689 return nil
8690}
8691
8692func (t *Pipeline_PushTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
8693 *t = Pipeline_PushTriggerData{}
8694
8695 cr := cbg.NewCborReader(r)
8696
8697 maj, extra, err := cr.ReadHeader()
8698 if err != nil {
8699 return err
8700 }
8701 defer func() {
8702 if err == io.EOF {
8703 err = io.ErrUnexpectedEOF
8704 }
8705 }()
8706
8707 if maj != cbg.MajMap {
8708 return fmt.Errorf("cbor input should be of type map")
8709 }
8710
8711 if extra > cbg.MaxLength {
8712 return fmt.Errorf("Pipeline_PushTriggerData: map struct too large (%d)", extra)
8713 }
8714
8715 n := extra
8716
8717 nameBuf := make([]byte, 6)
8718 for i := uint64(0); i < n; i++ {
8719 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8720 if err != nil {
8721 return err
8722 }
8723
8724 if !ok {
8725 // Field doesn't exist on this type, so ignore it
8726 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8727 return err
8728 }
8729 continue
8730 }
8731
8732 switch string(nameBuf[:nameLen]) {
8733 // t.Ref (string) (string)
8734 case "ref":
8735
8736 {
8737 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8738 if err != nil {
8739 return err
8740 }
8741
8742 t.Ref = string(sval)
8743 }
8744 // t.NewSha (string) (string)
8745 case "newSha":
8746
8747 {
8748 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8749 if err != nil {
8750 return err
8751 }
8752
8753 t.NewSha = string(sval)
8754 }
8755 // t.OldSha (string) (string)
8756 case "oldSha":
8757
8758 {
8759 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8760 if err != nil {
8761 return err
8762 }
8763
8764 t.OldSha = string(sval)
8765 }
8766
8767 default:
8768 // Field doesn't exist on this type, so ignore it
8769 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8770 return err
8771 }
8772 }
8773 }
8774
8775 return nil
8776}
8777func (t *PipelineStatus) MarshalCBOR(w io.Writer) error {
8778 if t == nil {
8779 _, err := w.Write(cbg.CborNull)
8780 return err
8781 }
8782
8783 cw := cbg.NewCborWriter(w)
8784 fieldCount := 7
8785
8786 if t.Error == nil {
8787 fieldCount--
8788 }
8789
8790 if t.ExitCode == nil {
8791 fieldCount--
8792 }
8793
8794 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
8795 return err
8796 }
8797
8798 // t.LexiconTypeID (string) (string)
8799 if len("$type") > 1000000 {
8800 return xerrors.Errorf("Value in field \"$type\" was too long")
8801 }
8802
8803 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8804 return err
8805 }
8806 if _, err := cw.WriteString(string("$type")); err != nil {
8807 return err
8808 }
8809
8810 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline.status"))); err != nil {
8811 return err
8812 }
8813 if _, err := cw.WriteString(string("sh.tangled.pipeline.status")); err != nil {
8814 return err
8815 }
8816
8817 // t.Error (string) (string)
8818 if t.Error != nil {
8819
8820 if len("error") > 1000000 {
8821 return xerrors.Errorf("Value in field \"error\" was too long")
8822 }
8823
8824 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("error"))); err != nil {
8825 return err
8826 }
8827 if _, err := cw.WriteString(string("error")); err != nil {
8828 return err
8829 }
8830
8831 if t.Error == nil {
8832 if _, err := cw.Write(cbg.CborNull); err != nil {
8833 return err
8834 }
8835 } else {
8836 if len(*t.Error) > 1000000 {
8837 return xerrors.Errorf("Value in field t.Error was too long")
8838 }
8839
8840 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Error))); err != nil {
8841 return err
8842 }
8843 if _, err := cw.WriteString(string(*t.Error)); err != nil {
8844 return err
8845 }
8846 }
8847 }
8848
8849 // t.Status (string) (string)
8850 if len("status") > 1000000 {
8851 return xerrors.Errorf("Value in field \"status\" was too long")
8852 }
8853
8854 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
8855 return err
8856 }
8857 if _, err := cw.WriteString(string("status")); err != nil {
8858 return err
8859 }
8860
8861 if len(t.Status) > 1000000 {
8862 return xerrors.Errorf("Value in field t.Status was too long")
8863 }
8864
8865 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
8866 return err
8867 }
8868 if _, err := cw.WriteString(string(t.Status)); err != nil {
8869 return err
8870 }
8871
8872 // t.ExitCode (int64) (int64)
8873 if t.ExitCode != nil {
8874
8875 if len("exitCode") > 1000000 {
8876 return xerrors.Errorf("Value in field \"exitCode\" was too long")
8877 }
8878
8879 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("exitCode"))); err != nil {
8880 return err
8881 }
8882 if _, err := cw.WriteString(string("exitCode")); err != nil {
8883 return err
8884 }
8885
8886 if t.ExitCode == nil {
8887 if _, err := cw.Write(cbg.CborNull); err != nil {
8888 return err
8889 }
8890 } else {
8891 if *t.ExitCode >= 0 {
8892 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.ExitCode)); err != nil {
8893 return err
8894 }
8895 } else {
8896 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.ExitCode-1)); err != nil {
8897 return err
8898 }
8899 }
8900 }
8901
8902 }
8903
8904 // t.Pipeline (string) (string)
8905 if len("pipeline") > 1000000 {
8906 return xerrors.Errorf("Value in field \"pipeline\" was too long")
8907 }
8908
8909 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pipeline"))); err != nil {
8910 return err
8911 }
8912 if _, err := cw.WriteString(string("pipeline")); err != nil {
8913 return err
8914 }
8915
8916 if len(t.Pipeline) > 1000000 {
8917 return xerrors.Errorf("Value in field t.Pipeline was too long")
8918 }
8919
8920 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pipeline))); err != nil {
8921 return err
8922 }
8923 if _, err := cw.WriteString(string(t.Pipeline)); err != nil {
8924 return err
8925 }
8926
8927 // t.Workflow (string) (string)
8928 if len("workflow") > 1000000 {
8929 return xerrors.Errorf("Value in field \"workflow\" was too long")
8930 }
8931
8932 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil {
8933 return err
8934 }
8935 if _, err := cw.WriteString(string("workflow")); err != nil {
8936 return err
8937 }
8938
8939 if len(t.Workflow) > 1000000 {
8940 return xerrors.Errorf("Value in field t.Workflow was too long")
8941 }
8942
8943 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil {
8944 return err
8945 }
8946 if _, err := cw.WriteString(string(t.Workflow)); err != nil {
8947 return err
8948 }
8949
8950 // t.CreatedAt (string) (string)
8951 if len("createdAt") > 1000000 {
8952 return xerrors.Errorf("Value in field \"createdAt\" was too long")
8953 }
8954
8955 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
8956 return err
8957 }
8958 if _, err := cw.WriteString(string("createdAt")); err != nil {
8959 return err
8960 }
8961
8962 if len(t.CreatedAt) > 1000000 {
8963 return xerrors.Errorf("Value in field t.CreatedAt was too long")
8964 }
8965
8966 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
8967 return err
8968 }
8969 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
8970 return err
8971 }
8972 return nil
8973}
8974
8975func (t *PipelineStatus) UnmarshalCBOR(r io.Reader) (err error) {
8976 *t = PipelineStatus{}
8977
8978 cr := cbg.NewCborReader(r)
8979
8980 maj, extra, err := cr.ReadHeader()
8981 if err != nil {
8982 return err
8983 }
8984 defer func() {
8985 if err == io.EOF {
8986 err = io.ErrUnexpectedEOF
8987 }
8988 }()
8989
8990 if maj != cbg.MajMap {
8991 return fmt.Errorf("cbor input should be of type map")
8992 }
8993
8994 if extra > cbg.MaxLength {
8995 return fmt.Errorf("PipelineStatus: map struct too large (%d)", extra)
8996 }
8997
8998 n := extra
8999
9000 nameBuf := make([]byte, 9)
9001 for i := uint64(0); i < n; i++ {
9002 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9003 if err != nil {
9004 return err
9005 }
9006
9007 if !ok {
9008 // Field doesn't exist on this type, so ignore it
9009 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9010 return err
9011 }
9012 continue
9013 }
9014
9015 switch string(nameBuf[:nameLen]) {
9016 // t.LexiconTypeID (string) (string)
9017 case "$type":
9018
9019 {
9020 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9021 if err != nil {
9022 return err
9023 }
9024
9025 t.LexiconTypeID = string(sval)
9026 }
9027 // t.Error (string) (string)
9028 case "error":
9029
9030 {
9031 b, err := cr.ReadByte()
9032 if err != nil {
9033 return err
9034 }
9035 if b != cbg.CborNull[0] {
9036 if err := cr.UnreadByte(); err != nil {
9037 return err
9038 }
9039
9040 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9041 if err != nil {
9042 return err
9043 }
9044
9045 t.Error = (*string)(&sval)
9046 }
9047 }
9048 // t.Status (string) (string)
9049 case "status":
9050
9051 {
9052 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9053 if err != nil {
9054 return err
9055 }
9056
9057 t.Status = string(sval)
9058 }
9059 // t.ExitCode (int64) (int64)
9060 case "exitCode":
9061 {
9062
9063 b, err := cr.ReadByte()
9064 if err != nil {
9065 return err
9066 }
9067 if b != cbg.CborNull[0] {
9068 if err := cr.UnreadByte(); err != nil {
9069 return err
9070 }
9071 maj, extra, err := cr.ReadHeader()
9072 if err != nil {
9073 return err
9074 }
9075 var extraI int64
9076 switch maj {
9077 case cbg.MajUnsignedInt:
9078 extraI = int64(extra)
9079 if extraI < 0 {
9080 return fmt.Errorf("int64 positive overflow")
9081 }
9082 case cbg.MajNegativeInt:
9083 extraI = int64(extra)
9084 if extraI < 0 {
9085 return fmt.Errorf("int64 negative overflow")
9086 }
9087 extraI = -1 - extraI
9088 default:
9089 return fmt.Errorf("wrong type for int64 field: %d", maj)
9090 }
9091
9092 t.ExitCode = (*int64)(&extraI)
9093 }
9094 }
9095 // t.Pipeline (string) (string)
9096 case "pipeline":
9097
9098 {
9099 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9100 if err != nil {
9101 return err
9102 }
9103
9104 t.Pipeline = string(sval)
9105 }
9106 // t.Workflow (string) (string)
9107 case "workflow":
9108
9109 {
9110 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9111 if err != nil {
9112 return err
9113 }
9114
9115 t.Workflow = string(sval)
9116 }
9117 // t.CreatedAt (string) (string)
9118 case "createdAt":
9119
9120 {
9121 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9122 if err != nil {
9123 return err
9124 }
9125
9126 t.CreatedAt = string(sval)
9127 }
9128
9129 default:
9130 // Field doesn't exist on this type, so ignore it
9131 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9132 return err
9133 }
9134 }
9135 }
9136
9137 return nil
9138}
9139func (t *Pipeline_TriggerMetadata) MarshalCBOR(w io.Writer) error {
9140 if t == nil {
9141 _, err := w.Write(cbg.CborNull)
9142 return err
9143 }
9144
9145 cw := cbg.NewCborWriter(w)
9146 fieldCount := 6
9147
9148 if t.Manual == nil {
9149 fieldCount--
9150 }
9151
9152 if t.PullRequest == nil {
9153 fieldCount--
9154 }
9155
9156 if t.Push == nil {
9157 fieldCount--
9158 }
9159
9160 if t.SourceRepo == nil {
9161 fieldCount--
9162 }
9163
9164 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
9165 return err
9166 }
9167
9168 // t.Kind (string) (string)
9169 if len("kind") > 1000000 {
9170 return xerrors.Errorf("Value in field \"kind\" was too long")
9171 }
9172
9173 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("kind"))); err != nil {
9174 return err
9175 }
9176 if _, err := cw.WriteString(string("kind")); err != nil {
9177 return err
9178 }
9179
9180 if len(t.Kind) > 1000000 {
9181 return xerrors.Errorf("Value in field t.Kind was too long")
9182 }
9183
9184 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Kind))); err != nil {
9185 return err
9186 }
9187 if _, err := cw.WriteString(string(t.Kind)); err != nil {
9188 return err
9189 }
9190
9191 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
9192 if t.Push != nil {
9193
9194 if len("push") > 1000000 {
9195 return xerrors.Errorf("Value in field \"push\" was too long")
9196 }
9197
9198 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("push"))); err != nil {
9199 return err
9200 }
9201 if _, err := cw.WriteString(string("push")); err != nil {
9202 return err
9203 }
9204
9205 if err := t.Push.MarshalCBOR(cw); err != nil {
9206 return err
9207 }
9208 }
9209
9210 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
9211 if len("repo") > 1000000 {
9212 return xerrors.Errorf("Value in field \"repo\" was too long")
9213 }
9214
9215 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
9216 return err
9217 }
9218 if _, err := cw.WriteString(string("repo")); err != nil {
9219 return err
9220 }
9221
9222 if err := t.Repo.MarshalCBOR(cw); err != nil {
9223 return err
9224 }
9225
9226 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
9227 if t.Manual != nil {
9228
9229 if len("manual") > 1000000 {
9230 return xerrors.Errorf("Value in field \"manual\" was too long")
9231 }
9232
9233 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("manual"))); err != nil {
9234 return err
9235 }
9236 if _, err := cw.WriteString(string("manual")); err != nil {
9237 return err
9238 }
9239
9240 if err := t.Manual.MarshalCBOR(cw); err != nil {
9241 return err
9242 }
9243 }
9244
9245 // t.SourceRepo (string) (string)
9246 if t.SourceRepo != nil {
9247
9248 if len("sourceRepo") > 1000000 {
9249 return xerrors.Errorf("Value in field \"sourceRepo\" was too long")
9250 }
9251
9252 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceRepo"))); err != nil {
9253 return err
9254 }
9255 if _, err := cw.WriteString(string("sourceRepo")); err != nil {
9256 return err
9257 }
9258
9259 if t.SourceRepo == nil {
9260 if _, err := cw.Write(cbg.CborNull); err != nil {
9261 return err
9262 }
9263 } else {
9264 if len(*t.SourceRepo) > 1000000 {
9265 return xerrors.Errorf("Value in field t.SourceRepo was too long")
9266 }
9267
9268 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.SourceRepo))); err != nil {
9269 return err
9270 }
9271 if _, err := cw.WriteString(string(*t.SourceRepo)); err != nil {
9272 return err
9273 }
9274 }
9275 }
9276
9277 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
9278 if t.PullRequest != nil {
9279
9280 if len("pullRequest") > 1000000 {
9281 return xerrors.Errorf("Value in field \"pullRequest\" was too long")
9282 }
9283
9284 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullRequest"))); err != nil {
9285 return err
9286 }
9287 if _, err := cw.WriteString(string("pullRequest")); err != nil {
9288 return err
9289 }
9290
9291 if err := t.PullRequest.MarshalCBOR(cw); err != nil {
9292 return err
9293 }
9294 }
9295 return nil
9296}
9297
9298func (t *Pipeline_TriggerMetadata) UnmarshalCBOR(r io.Reader) (err error) {
9299 *t = Pipeline_TriggerMetadata{}
9300
9301 cr := cbg.NewCborReader(r)
9302
9303 maj, extra, err := cr.ReadHeader()
9304 if err != nil {
9305 return err
9306 }
9307 defer func() {
9308 if err == io.EOF {
9309 err = io.ErrUnexpectedEOF
9310 }
9311 }()
9312
9313 if maj != cbg.MajMap {
9314 return fmt.Errorf("cbor input should be of type map")
9315 }
9316
9317 if extra > cbg.MaxLength {
9318 return fmt.Errorf("Pipeline_TriggerMetadata: map struct too large (%d)", extra)
9319 }
9320
9321 n := extra
9322
9323 nameBuf := make([]byte, 11)
9324 for i := uint64(0); i < n; i++ {
9325 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9326 if err != nil {
9327 return err
9328 }
9329
9330 if !ok {
9331 // Field doesn't exist on this type, so ignore it
9332 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9333 return err
9334 }
9335 continue
9336 }
9337
9338 switch string(nameBuf[:nameLen]) {
9339 // t.Kind (string) (string)
9340 case "kind":
9341
9342 {
9343 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9344 if err != nil {
9345 return err
9346 }
9347
9348 t.Kind = string(sval)
9349 }
9350 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
9351 case "push":
9352
9353 {
9354
9355 b, err := cr.ReadByte()
9356 if err != nil {
9357 return err
9358 }
9359 if b != cbg.CborNull[0] {
9360 if err := cr.UnreadByte(); err != nil {
9361 return err
9362 }
9363 t.Push = new(Pipeline_PushTriggerData)
9364 if err := t.Push.UnmarshalCBOR(cr); err != nil {
9365 return xerrors.Errorf("unmarshaling t.Push pointer: %w", err)
9366 }
9367 }
9368
9369 }
9370 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
9371 case "repo":
9372
9373 {
9374
9375 b, err := cr.ReadByte()
9376 if err != nil {
9377 return err
9378 }
9379 if b != cbg.CborNull[0] {
9380 if err := cr.UnreadByte(); err != nil {
9381 return err
9382 }
9383 t.Repo = new(Pipeline_TriggerRepo)
9384 if err := t.Repo.UnmarshalCBOR(cr); err != nil {
9385 return xerrors.Errorf("unmarshaling t.Repo pointer: %w", err)
9386 }
9387 }
9388
9389 }
9390 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
9391 case "manual":
9392
9393 {
9394
9395 b, err := cr.ReadByte()
9396 if err != nil {
9397 return err
9398 }
9399 if b != cbg.CborNull[0] {
9400 if err := cr.UnreadByte(); err != nil {
9401 return err
9402 }
9403 t.Manual = new(Pipeline_ManualTriggerData)
9404 if err := t.Manual.UnmarshalCBOR(cr); err != nil {
9405 return xerrors.Errorf("unmarshaling t.Manual pointer: %w", err)
9406 }
9407 }
9408
9409 }
9410 // t.SourceRepo (string) (string)
9411 case "sourceRepo":
9412
9413 {
9414 b, err := cr.ReadByte()
9415 if err != nil {
9416 return err
9417 }
9418 if b != cbg.CborNull[0] {
9419 if err := cr.UnreadByte(); err != nil {
9420 return err
9421 }
9422
9423 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9424 if err != nil {
9425 return err
9426 }
9427
9428 t.SourceRepo = (*string)(&sval)
9429 }
9430 }
9431 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
9432 case "pullRequest":
9433
9434 {
9435
9436 b, err := cr.ReadByte()
9437 if err != nil {
9438 return err
9439 }
9440 if b != cbg.CborNull[0] {
9441 if err := cr.UnreadByte(); err != nil {
9442 return err
9443 }
9444 t.PullRequest = new(Pipeline_PullRequestTriggerData)
9445 if err := t.PullRequest.UnmarshalCBOR(cr); err != nil {
9446 return xerrors.Errorf("unmarshaling t.PullRequest pointer: %w", err)
9447 }
9448 }
9449
9450 }
9451
9452 default:
9453 // Field doesn't exist on this type, so ignore it
9454 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9455 return err
9456 }
9457 }
9458 }
9459
9460 return nil
9461}
9462func (t *Pipeline_TriggerRepo) MarshalCBOR(w io.Writer) error {
9463 if t == nil {
9464 _, err := w.Write(cbg.CborNull)
9465 return err
9466 }
9467
9468 cw := cbg.NewCborWriter(w)
9469 fieldCount := 5
9470
9471 if t.Repo == nil {
9472 fieldCount--
9473 }
9474
9475 if t.RepoDid == nil {
9476 fieldCount--
9477 }
9478
9479 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
9480 return err
9481 }
9482
9483 // t.Did (string) (string)
9484 if len("did") > 1000000 {
9485 return xerrors.Errorf("Value in field \"did\" was too long")
9486 }
9487
9488 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil {
9489 return err
9490 }
9491 if _, err := cw.WriteString(string("did")); err != nil {
9492 return err
9493 }
9494
9495 if len(t.Did) > 1000000 {
9496 return xerrors.Errorf("Value in field t.Did was too long")
9497 }
9498
9499 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil {
9500 return err
9501 }
9502 if _, err := cw.WriteString(string(t.Did)); err != nil {
9503 return err
9504 }
9505
9506 // t.Knot (string) (string)
9507 if len("knot") > 1000000 {
9508 return xerrors.Errorf("Value in field \"knot\" was too long")
9509 }
9510
9511 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
9512 return err
9513 }
9514 if _, err := cw.WriteString(string("knot")); err != nil {
9515 return err
9516 }
9517
9518 if len(t.Knot) > 1000000 {
9519 return xerrors.Errorf("Value in field t.Knot was too long")
9520 }
9521
9522 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
9523 return err
9524 }
9525 if _, err := cw.WriteString(string(t.Knot)); err != nil {
9526 return err
9527 }
9528
9529 // t.Repo (string) (string)
9530 if t.Repo != nil {
9531
9532 if len("repo") > 1000000 {
9533 return xerrors.Errorf("Value in field \"repo\" was too long")
9534 }
9535
9536 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
9537 return err
9538 }
9539 if _, err := cw.WriteString(string("repo")); err != nil {
9540 return err
9541 }
9542
9543 if t.Repo == nil {
9544 if _, err := cw.Write(cbg.CborNull); err != nil {
9545 return err
9546 }
9547 } else {
9548 if len(*t.Repo) > 1000000 {
9549 return xerrors.Errorf("Value in field t.Repo was too long")
9550 }
9551
9552 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
9553 return err
9554 }
9555 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
9556 return err
9557 }
9558 }
9559 }
9560
9561 // t.RepoDid (string) (string)
9562 if t.RepoDid != nil {
9563
9564 if len("repoDid") > 1000000 {
9565 return xerrors.Errorf("Value in field \"repoDid\" was too long")
9566 }
9567
9568 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
9569 return err
9570 }
9571 if _, err := cw.WriteString(string("repoDid")); err != nil {
9572 return err
9573 }
9574
9575 if t.RepoDid == nil {
9576 if _, err := cw.Write(cbg.CborNull); err != nil {
9577 return err
9578 }
9579 } else {
9580 if len(*t.RepoDid) > 1000000 {
9581 return xerrors.Errorf("Value in field t.RepoDid was too long")
9582 }
9583
9584 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil {
9585 return err
9586 }
9587 if _, err := cw.WriteString(string(*t.RepoDid)); err != nil {
9588 return err
9589 }
9590 }
9591 }
9592
9593 // t.DefaultBranch (string) (string)
9594 if len("defaultBranch") > 1000000 {
9595 return xerrors.Errorf("Value in field \"defaultBranch\" was too long")
9596 }
9597
9598 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("defaultBranch"))); err != nil {
9599 return err
9600 }
9601 if _, err := cw.WriteString(string("defaultBranch")); err != nil {
9602 return err
9603 }
9604
9605 if len(t.DefaultBranch) > 1000000 {
9606 return xerrors.Errorf("Value in field t.DefaultBranch was too long")
9607 }
9608
9609 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.DefaultBranch))); err != nil {
9610 return err
9611 }
9612 if _, err := cw.WriteString(string(t.DefaultBranch)); err != nil {
9613 return err
9614 }
9615 return nil
9616}
9617
9618func (t *Pipeline_TriggerRepo) UnmarshalCBOR(r io.Reader) (err error) {
9619 *t = Pipeline_TriggerRepo{}
9620
9621 cr := cbg.NewCborReader(r)
9622
9623 maj, extra, err := cr.ReadHeader()
9624 if err != nil {
9625 return err
9626 }
9627 defer func() {
9628 if err == io.EOF {
9629 err = io.ErrUnexpectedEOF
9630 }
9631 }()
9632
9633 if maj != cbg.MajMap {
9634 return fmt.Errorf("cbor input should be of type map")
9635 }
9636
9637 if extra > cbg.MaxLength {
9638 return fmt.Errorf("Pipeline_TriggerRepo: map struct too large (%d)", extra)
9639 }
9640
9641 n := extra
9642
9643 nameBuf := make([]byte, 13)
9644 for i := uint64(0); i < n; i++ {
9645 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9646 if err != nil {
9647 return err
9648 }
9649
9650 if !ok {
9651 // Field doesn't exist on this type, so ignore it
9652 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9653 return err
9654 }
9655 continue
9656 }
9657
9658 switch string(nameBuf[:nameLen]) {
9659 // t.Did (string) (string)
9660 case "did":
9661
9662 {
9663 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9664 if err != nil {
9665 return err
9666 }
9667
9668 t.Did = string(sval)
9669 }
9670 // t.Knot (string) (string)
9671 case "knot":
9672
9673 {
9674 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9675 if err != nil {
9676 return err
9677 }
9678
9679 t.Knot = string(sval)
9680 }
9681 // t.Repo (string) (string)
9682 case "repo":
9683
9684 {
9685 b, err := cr.ReadByte()
9686 if err != nil {
9687 return err
9688 }
9689 if b != cbg.CborNull[0] {
9690 if err := cr.UnreadByte(); err != nil {
9691 return err
9692 }
9693
9694 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9695 if err != nil {
9696 return err
9697 }
9698
9699 t.Repo = (*string)(&sval)
9700 }
9701 }
9702 // t.RepoDid (string) (string)
9703 case "repoDid":
9704
9705 {
9706 b, err := cr.ReadByte()
9707 if err != nil {
9708 return err
9709 }
9710 if b != cbg.CborNull[0] {
9711 if err := cr.UnreadByte(); err != nil {
9712 return err
9713 }
9714
9715 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9716 if err != nil {
9717 return err
9718 }
9719
9720 t.RepoDid = (*string)(&sval)
9721 }
9722 }
9723 // t.DefaultBranch (string) (string)
9724 case "defaultBranch":
9725
9726 {
9727 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9728 if err != nil {
9729 return err
9730 }
9731
9732 t.DefaultBranch = string(sval)
9733 }
9734
9735 default:
9736 // Field doesn't exist on this type, so ignore it
9737 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9738 return err
9739 }
9740 }
9741 }
9742
9743 return nil
9744}
9745func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error {
9746 if t == nil {
9747 _, err := w.Write(cbg.CborNull)
9748 return err
9749 }
9750
9751 cw := cbg.NewCborWriter(w)
9752
9753 if _, err := cw.Write([]byte{164}); err != nil {
9754 return err
9755 }
9756
9757 // t.Raw (string) (string)
9758 if len("raw") > 1000000 {
9759 return xerrors.Errorf("Value in field \"raw\" was too long")
9760 }
9761
9762 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("raw"))); err != nil {
9763 return err
9764 }
9765 if _, err := cw.WriteString(string("raw")); err != nil {
9766 return err
9767 }
9768
9769 if len(t.Raw) > 1000000 {
9770 return xerrors.Errorf("Value in field t.Raw was too long")
9771 }
9772
9773 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Raw))); err != nil {
9774 return err
9775 }
9776 if _, err := cw.WriteString(string(t.Raw)); err != nil {
9777 return err
9778 }
9779
9780 // t.Name (string) (string)
9781 if len("name") > 1000000 {
9782 return xerrors.Errorf("Value in field \"name\" was too long")
9783 }
9784
9785 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
9786 return err
9787 }
9788 if _, err := cw.WriteString(string("name")); err != nil {
9789 return err
9790 }
9791
9792 if len(t.Name) > 1000000 {
9793 return xerrors.Errorf("Value in field t.Name was too long")
9794 }
9795
9796 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
9797 return err
9798 }
9799 if _, err := cw.WriteString(string(t.Name)); err != nil {
9800 return err
9801 }
9802
9803 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
9804 if len("clone") > 1000000 {
9805 return xerrors.Errorf("Value in field \"clone\" was too long")
9806 }
9807
9808 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil {
9809 return err
9810 }
9811 if _, err := cw.WriteString(string("clone")); err != nil {
9812 return err
9813 }
9814
9815 if err := t.Clone.MarshalCBOR(cw); err != nil {
9816 return err
9817 }
9818
9819 // t.Engine (string) (string)
9820 if len("engine") > 1000000 {
9821 return xerrors.Errorf("Value in field \"engine\" was too long")
9822 }
9823
9824 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("engine"))); err != nil {
9825 return err
9826 }
9827 if _, err := cw.WriteString(string("engine")); err != nil {
9828 return err
9829 }
9830
9831 if len(t.Engine) > 1000000 {
9832 return xerrors.Errorf("Value in field t.Engine was too long")
9833 }
9834
9835 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Engine))); err != nil {
9836 return err
9837 }
9838 if _, err := cw.WriteString(string(t.Engine)); err != nil {
9839 return err
9840 }
9841 return nil
9842}
9843
9844func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) {
9845 *t = Pipeline_Workflow{}
9846
9847 cr := cbg.NewCborReader(r)
9848
9849 maj, extra, err := cr.ReadHeader()
9850 if err != nil {
9851 return err
9852 }
9853 defer func() {
9854 if err == io.EOF {
9855 err = io.ErrUnexpectedEOF
9856 }
9857 }()
9858
9859 if maj != cbg.MajMap {
9860 return fmt.Errorf("cbor input should be of type map")
9861 }
9862
9863 if extra > cbg.MaxLength {
9864 return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra)
9865 }
9866
9867 n := extra
9868
9869 nameBuf := make([]byte, 6)
9870 for i := uint64(0); i < n; i++ {
9871 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9872 if err != nil {
9873 return err
9874 }
9875
9876 if !ok {
9877 // Field doesn't exist on this type, so ignore it
9878 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9879 return err
9880 }
9881 continue
9882 }
9883
9884 switch string(nameBuf[:nameLen]) {
9885 // t.Raw (string) (string)
9886 case "raw":
9887
9888 {
9889 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9890 if err != nil {
9891 return err
9892 }
9893
9894 t.Raw = string(sval)
9895 }
9896 // t.Name (string) (string)
9897 case "name":
9898
9899 {
9900 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9901 if err != nil {
9902 return err
9903 }
9904
9905 t.Name = string(sval)
9906 }
9907 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
9908 case "clone":
9909
9910 {
9911
9912 b, err := cr.ReadByte()
9913 if err != nil {
9914 return err
9915 }
9916 if b != cbg.CborNull[0] {
9917 if err := cr.UnreadByte(); err != nil {
9918 return err
9919 }
9920 t.Clone = new(Pipeline_CloneOpts)
9921 if err := t.Clone.UnmarshalCBOR(cr); err != nil {
9922 return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err)
9923 }
9924 }
9925
9926 }
9927 // t.Engine (string) (string)
9928 case "engine":
9929
9930 {
9931 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9932 if err != nil {
9933 return err
9934 }
9935
9936 t.Engine = string(sval)
9937 }
9938
9939 default:
9940 // Field doesn't exist on this type, so ignore it
9941 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9942 return err
9943 }
9944 }
9945 }
9946
9947 return nil
9948}
9949func (t *PublicKey) MarshalCBOR(w io.Writer) error {
9950 if t == nil {
9951 _, err := w.Write(cbg.CborNull)
9952 return err
9953 }
9954
9955 cw := cbg.NewCborWriter(w)
9956
9957 if _, err := cw.Write([]byte{164}); err != nil {
9958 return err
9959 }
9960
9961 // t.Key (string) (string)
9962 if len("key") > 1000000 {
9963 return xerrors.Errorf("Value in field \"key\" was too long")
9964 }
9965
9966 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
9967 return err
9968 }
9969 if _, err := cw.WriteString(string("key")); err != nil {
9970 return err
9971 }
9972
9973 if len(t.Key) > 1000000 {
9974 return xerrors.Errorf("Value in field t.Key was too long")
9975 }
9976
9977 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
9978 return err
9979 }
9980 if _, err := cw.WriteString(string(t.Key)); err != nil {
9981 return err
9982 }
9983
9984 // t.Name (string) (string)
9985 if len("name") > 1000000 {
9986 return xerrors.Errorf("Value in field \"name\" was too long")
9987 }
9988
9989 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
9990 return err
9991 }
9992 if _, err := cw.WriteString(string("name")); err != nil {
9993 return err
9994 }
9995
9996 if len(t.Name) > 1000000 {
9997 return xerrors.Errorf("Value in field t.Name was too long")
9998 }
9999
10000 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
10001 return err
10002 }
10003 if _, err := cw.WriteString(string(t.Name)); err != nil {
10004 return err
10005 }
10006
10007 // t.LexiconTypeID (string) (string)
10008 if len("$type") > 1000000 {
10009 return xerrors.Errorf("Value in field \"$type\" was too long")
10010 }
10011
10012 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
10013 return err
10014 }
10015 if _, err := cw.WriteString(string("$type")); err != nil {
10016 return err
10017 }
10018
10019 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil {
10020 return err
10021 }
10022 if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil {
10023 return err
10024 }
10025
10026 // t.CreatedAt (string) (string)
10027 if len("createdAt") > 1000000 {
10028 return xerrors.Errorf("Value in field \"createdAt\" was too long")
10029 }
10030
10031 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
10032 return err
10033 }
10034 if _, err := cw.WriteString(string("createdAt")); err != nil {
10035 return err
10036 }
10037
10038 if len(t.CreatedAt) > 1000000 {
10039 return xerrors.Errorf("Value in field t.CreatedAt was too long")
10040 }
10041
10042 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
10043 return err
10044 }
10045 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
10046 return err
10047 }
10048 return nil
10049}
10050
10051func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) {
10052 *t = PublicKey{}
10053
10054 cr := cbg.NewCborReader(r)
10055
10056 maj, extra, err := cr.ReadHeader()
10057 if err != nil {
10058 return err
10059 }
10060 defer func() {
10061 if err == io.EOF {
10062 err = io.ErrUnexpectedEOF
10063 }
10064 }()
10065
10066 if maj != cbg.MajMap {
10067 return fmt.Errorf("cbor input should be of type map")
10068 }
10069
10070 if extra > cbg.MaxLength {
10071 return fmt.Errorf("PublicKey: map struct too large (%d)", extra)
10072 }
10073
10074 n := extra
10075
10076 nameBuf := make([]byte, 9)
10077 for i := uint64(0); i < n; i++ {
10078 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
10079 if err != nil {
10080 return err
10081 }
10082
10083 if !ok {
10084 // Field doesn't exist on this type, so ignore it
10085 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
10086 return err
10087 }
10088 continue
10089 }
10090
10091 switch string(nameBuf[:nameLen]) {
10092 // t.Key (string) (string)
10093 case "key":
10094
10095 {
10096 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10097 if err != nil {
10098 return err
10099 }
10100
10101 t.Key = string(sval)
10102 }
10103 // t.Name (string) (string)
10104 case "name":
10105
10106 {
10107 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10108 if err != nil {
10109 return err
10110 }
10111
10112 t.Name = string(sval)
10113 }
10114 // t.LexiconTypeID (string) (string)
10115 case "$type":
10116
10117 {
10118 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10119 if err != nil {
10120 return err
10121 }
10122
10123 t.LexiconTypeID = string(sval)
10124 }
10125 // t.CreatedAt (string) (string)
10126 case "createdAt":
10127
10128 {
10129 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10130 if err != nil {
10131 return err
10132 }
10133
10134 t.CreatedAt = string(sval)
10135 }
10136
10137 default:
10138 // Field doesn't exist on this type, so ignore it
10139 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
10140 return err
10141 }
10142 }
10143 }
10144
10145 return nil
10146}
10147func (t *Repo) MarshalCBOR(w io.Writer) error {
10148 if t == nil {
10149 _, err := w.Write(cbg.CborNull)
10150 return err
10151 }
10152
10153 cw := cbg.NewCborWriter(w)
10154 fieldCount := 11
10155
10156 if t.Description == nil {
10157 fieldCount--
10158 }
10159
10160 if t.Labels == nil {
10161 fieldCount--
10162 }
10163
10164 if t.Name == nil {
10165 fieldCount--
10166 }
10167
10168 if t.RepoDid == nil {
10169 fieldCount--
10170 }
10171
10172 if t.Source == nil {
10173 fieldCount--
10174 }
10175
10176 if t.Spindle == nil {
10177 fieldCount--
10178 }
10179
10180 if t.Topics == nil {
10181 fieldCount--
10182 }
10183
10184 if t.Website == nil {
10185 fieldCount--
10186 }
10187
10188 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
10189 return err
10190 }
10191
10192 // t.Knot (string) (string)
10193 if len("knot") > 1000000 {
10194 return xerrors.Errorf("Value in field \"knot\" was too long")
10195 }
10196
10197 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
10198 return err
10199 }
10200 if _, err := cw.WriteString(string("knot")); err != nil {
10201 return err
10202 }
10203
10204 if len(t.Knot) > 1000000 {
10205 return xerrors.Errorf("Value in field t.Knot was too long")
10206 }
10207
10208 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
10209 return err
10210 }
10211 if _, err := cw.WriteString(string(t.Knot)); err != nil {
10212 return err
10213 }
10214
10215 // t.Name (string) (string)
10216 if t.Name != nil {
10217
10218 if len("name") > 1000000 {
10219 return xerrors.Errorf("Value in field \"name\" was too long")
10220 }
10221
10222 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
10223 return err
10224 }
10225 if _, err := cw.WriteString(string("name")); err != nil {
10226 return err
10227 }
10228
10229 if t.Name == nil {
10230 if _, err := cw.Write(cbg.CborNull); err != nil {
10231 return err
10232 }
10233 } else {
10234 if len(*t.Name) > 1000000 {
10235 return xerrors.Errorf("Value in field t.Name was too long")
10236 }
10237
10238 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Name))); err != nil {
10239 return err
10240 }
10241 if _, err := cw.WriteString(string(*t.Name)); err != nil {
10242 return err
10243 }
10244 }
10245 }
10246
10247 // t.LexiconTypeID (string) (string)
10248 if len("$type") > 1000000 {
10249 return xerrors.Errorf("Value in field \"$type\" was too long")
10250 }
10251
10252 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
10253 return err
10254 }
10255 if _, err := cw.WriteString(string("$type")); err != nil {
10256 return err
10257 }
10258
10259 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil {
10260 return err
10261 }
10262 if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil {
10263 return err
10264 }
10265
10266 // t.Labels ([]string) (slice)
10267 if t.Labels != nil {
10268
10269 if len("labels") > 1000000 {
10270 return xerrors.Errorf("Value in field \"labels\" was too long")
10271 }
10272
10273 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("labels"))); err != nil {
10274 return err
10275 }
10276 if _, err := cw.WriteString(string("labels")); err != nil {
10277 return err
10278 }
10279
10280 if len(t.Labels) > 8192 {
10281 return xerrors.Errorf("Slice value in field t.Labels was too long")
10282 }
10283
10284 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Labels))); err != nil {
10285 return err
10286 }
10287 for _, v := range t.Labels {
10288 if len(v) > 1000000 {
10289 return xerrors.Errorf("Value in field v was too long")
10290 }
10291
10292 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
10293 return err
10294 }
10295 if _, err := cw.WriteString(string(v)); err != nil {
10296 return err
10297 }
10298
10299 }
10300 }
10301
10302 // t.Source (string) (string)
10303 if t.Source != nil {
10304
10305 if len("source") > 1000000 {
10306 return xerrors.Errorf("Value in field \"source\" was too long")
10307 }
10308
10309 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
10310 return err
10311 }
10312 if _, err := cw.WriteString(string("source")); err != nil {
10313 return err
10314 }
10315
10316 if t.Source == nil {
10317 if _, err := cw.Write(cbg.CborNull); err != nil {
10318 return err
10319 }
10320 } else {
10321 if len(*t.Source) > 1000000 {
10322 return xerrors.Errorf("Value in field t.Source was too long")
10323 }
10324
10325 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil {
10326 return err
10327 }
10328 if _, err := cw.WriteString(string(*t.Source)); err != nil {
10329 return err
10330 }
10331 }
10332 }
10333
10334 // t.Topics ([]string) (slice)
10335 if t.Topics != nil {
10336
10337 if len("topics") > 1000000 {
10338 return xerrors.Errorf("Value in field \"topics\" was too long")
10339 }
10340
10341 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("topics"))); err != nil {
10342 return err
10343 }
10344 if _, err := cw.WriteString(string("topics")); err != nil {
10345 return err
10346 }
10347
10348 if len(t.Topics) > 8192 {
10349 return xerrors.Errorf("Slice value in field t.Topics was too long")
10350 }
10351
10352 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Topics))); err != nil {
10353 return err
10354 }
10355 for _, v := range t.Topics {
10356 if len(v) > 1000000 {
10357 return xerrors.Errorf("Value in field v was too long")
10358 }
10359
10360 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
10361 return err
10362 }
10363 if _, err := cw.WriteString(string(v)); err != nil {
10364 return err
10365 }
10366
10367 }
10368 }
10369
10370 // t.RepoDid (string) (string)
10371 if t.RepoDid != nil {
10372
10373 if len("repoDid") > 1000000 {
10374 return xerrors.Errorf("Value in field \"repoDid\" was too long")
10375 }
10376
10377 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
10378 return err
10379 }
10380 if _, err := cw.WriteString(string("repoDid")); err != nil {
10381 return err
10382 }
10383
10384 if t.RepoDid == nil {
10385 if _, err := cw.Write(cbg.CborNull); err != nil {
10386 return err
10387 }
10388 } else {
10389 if len(*t.RepoDid) > 1000000 {
10390 return xerrors.Errorf("Value in field t.RepoDid was too long")
10391 }
10392
10393 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil {
10394 return err
10395 }
10396 if _, err := cw.WriteString(string(*t.RepoDid)); err != nil {
10397 return err
10398 }
10399 }
10400 }
10401
10402 // t.Spindle (string) (string)
10403 if t.Spindle != nil {
10404
10405 if len("spindle") > 1000000 {
10406 return xerrors.Errorf("Value in field \"spindle\" was too long")
10407 }
10408
10409 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("spindle"))); err != nil {
10410 return err
10411 }
10412 if _, err := cw.WriteString(string("spindle")); err != nil {
10413 return err
10414 }
10415
10416 if t.Spindle == nil {
10417 if _, err := cw.Write(cbg.CborNull); err != nil {
10418 return err
10419 }
10420 } else {
10421 if len(*t.Spindle) > 1000000 {
10422 return xerrors.Errorf("Value in field t.Spindle was too long")
10423 }
10424
10425 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Spindle))); err != nil {
10426 return err
10427 }
10428 if _, err := cw.WriteString(string(*t.Spindle)); err != nil {
10429 return err
10430 }
10431 }
10432 }
10433
10434 // t.Website (string) (string)
10435 if t.Website != nil {
10436
10437 if len("website") > 1000000 {
10438 return xerrors.Errorf("Value in field \"website\" was too long")
10439 }
10440
10441 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("website"))); err != nil {
10442 return err
10443 }
10444 if _, err := cw.WriteString(string("website")); err != nil {
10445 return err
10446 }
10447
10448 if t.Website == nil {
10449 if _, err := cw.Write(cbg.CborNull); err != nil {
10450 return err
10451 }
10452 } else {
10453 if len(*t.Website) > 1000000 {
10454 return xerrors.Errorf("Value in field t.Website was too long")
10455 }
10456
10457 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Website))); err != nil {
10458 return err
10459 }
10460 if _, err := cw.WriteString(string(*t.Website)); err != nil {
10461 return err
10462 }
10463 }
10464 }
10465
10466 // t.CreatedAt (string) (string)
10467 if len("createdAt") > 1000000 {
10468 return xerrors.Errorf("Value in field \"createdAt\" was too long")
10469 }
10470
10471 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
10472 return err
10473 }
10474 if _, err := cw.WriteString(string("createdAt")); err != nil {
10475 return err
10476 }
10477
10478 if len(t.CreatedAt) > 1000000 {
10479 return xerrors.Errorf("Value in field t.CreatedAt was too long")
10480 }
10481
10482 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
10483 return err
10484 }
10485 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
10486 return err
10487 }
10488
10489 // t.Description (string) (string)
10490 if t.Description != nil {
10491
10492 if len("description") > 1000000 {
10493 return xerrors.Errorf("Value in field \"description\" was too long")
10494 }
10495
10496 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
10497 return err
10498 }
10499 if _, err := cw.WriteString(string("description")); err != nil {
10500 return err
10501 }
10502
10503 if t.Description == nil {
10504 if _, err := cw.Write(cbg.CborNull); err != nil {
10505 return err
10506 }
10507 } else {
10508 if len(*t.Description) > 1000000 {
10509 return xerrors.Errorf("Value in field t.Description was too long")
10510 }
10511
10512 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
10513 return err
10514 }
10515 if _, err := cw.WriteString(string(*t.Description)); err != nil {
10516 return err
10517 }
10518 }
10519 }
10520 return nil
10521}
10522
10523func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) {
10524 *t = Repo{}
10525
10526 cr := cbg.NewCborReader(r)
10527
10528 maj, extra, err := cr.ReadHeader()
10529 if err != nil {
10530 return err
10531 }
10532 defer func() {
10533 if err == io.EOF {
10534 err = io.ErrUnexpectedEOF
10535 }
10536 }()
10537
10538 if maj != cbg.MajMap {
10539 return fmt.Errorf("cbor input should be of type map")
10540 }
10541
10542 if extra > cbg.MaxLength {
10543 return fmt.Errorf("Repo: map struct too large (%d)", extra)
10544 }
10545
10546 n := extra
10547
10548 nameBuf := make([]byte, 11)
10549 for i := uint64(0); i < n; i++ {
10550 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
10551 if err != nil {
10552 return err
10553 }
10554
10555 if !ok {
10556 // Field doesn't exist on this type, so ignore it
10557 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
10558 return err
10559 }
10560 continue
10561 }
10562
10563 switch string(nameBuf[:nameLen]) {
10564 // t.Knot (string) (string)
10565 case "knot":
10566
10567 {
10568 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10569 if err != nil {
10570 return err
10571 }
10572
10573 t.Knot = string(sval)
10574 }
10575 // t.Name (string) (string)
10576 case "name":
10577
10578 {
10579 b, err := cr.ReadByte()
10580 if err != nil {
10581 return err
10582 }
10583 if b != cbg.CborNull[0] {
10584 if err := cr.UnreadByte(); err != nil {
10585 return err
10586 }
10587
10588 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10589 if err != nil {
10590 return err
10591 }
10592
10593 t.Name = (*string)(&sval)
10594 }
10595 }
10596 // t.LexiconTypeID (string) (string)
10597 case "$type":
10598
10599 {
10600 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10601 if err != nil {
10602 return err
10603 }
10604
10605 t.LexiconTypeID = string(sval)
10606 }
10607 // t.Labels ([]string) (slice)
10608 case "labels":
10609
10610 maj, extra, err = cr.ReadHeader()
10611 if err != nil {
10612 return err
10613 }
10614
10615 if extra > 8192 {
10616 return fmt.Errorf("t.Labels: array too large (%d)", extra)
10617 }
10618
10619 if maj != cbg.MajArray {
10620 return fmt.Errorf("expected cbor array")
10621 }
10622
10623 if extra > 0 {
10624 t.Labels = make([]string, extra)
10625 }
10626
10627 for i := 0; i < int(extra); i++ {
10628 {
10629 var maj byte
10630 var extra uint64
10631 var err error
10632 _ = maj
10633 _ = extra
10634 _ = err
10635
10636 {
10637 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10638 if err != nil {
10639 return err
10640 }
10641
10642 t.Labels[i] = string(sval)
10643 }
10644
10645 }
10646 }
10647 // t.Source (string) (string)
10648 case "source":
10649
10650 {
10651 b, err := cr.ReadByte()
10652 if err != nil {
10653 return err
10654 }
10655 if b != cbg.CborNull[0] {
10656 if err := cr.UnreadByte(); err != nil {
10657 return err
10658 }
10659
10660 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10661 if err != nil {
10662 return err
10663 }
10664
10665 t.Source = (*string)(&sval)
10666 }
10667 }
10668 // t.Topics ([]string) (slice)
10669 case "topics":
10670
10671 maj, extra, err = cr.ReadHeader()
10672 if err != nil {
10673 return err
10674 }
10675
10676 if extra > 8192 {
10677 return fmt.Errorf("t.Topics: array too large (%d)", extra)
10678 }
10679
10680 if maj != cbg.MajArray {
10681 return fmt.Errorf("expected cbor array")
10682 }
10683
10684 if extra > 0 {
10685 t.Topics = make([]string, extra)
10686 }
10687
10688 for i := 0; i < int(extra); i++ {
10689 {
10690 var maj byte
10691 var extra uint64
10692 var err error
10693 _ = maj
10694 _ = extra
10695 _ = err
10696
10697 {
10698 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10699 if err != nil {
10700 return err
10701 }
10702
10703 t.Topics[i] = string(sval)
10704 }
10705
10706 }
10707 }
10708 // t.RepoDid (string) (string)
10709 case "repoDid":
10710
10711 {
10712 b, err := cr.ReadByte()
10713 if err != nil {
10714 return err
10715 }
10716 if b != cbg.CborNull[0] {
10717 if err := cr.UnreadByte(); err != nil {
10718 return err
10719 }
10720
10721 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10722 if err != nil {
10723 return err
10724 }
10725
10726 t.RepoDid = (*string)(&sval)
10727 }
10728 }
10729 // t.Spindle (string) (string)
10730 case "spindle":
10731
10732 {
10733 b, err := cr.ReadByte()
10734 if err != nil {
10735 return err
10736 }
10737 if b != cbg.CborNull[0] {
10738 if err := cr.UnreadByte(); err != nil {
10739 return err
10740 }
10741
10742 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10743 if err != nil {
10744 return err
10745 }
10746
10747 t.Spindle = (*string)(&sval)
10748 }
10749 }
10750 // t.Website (string) (string)
10751 case "website":
10752
10753 {
10754 b, err := cr.ReadByte()
10755 if err != nil {
10756 return err
10757 }
10758 if b != cbg.CborNull[0] {
10759 if err := cr.UnreadByte(); err != nil {
10760 return err
10761 }
10762
10763 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10764 if err != nil {
10765 return err
10766 }
10767
10768 t.Website = (*string)(&sval)
10769 }
10770 }
10771 // t.CreatedAt (string) (string)
10772 case "createdAt":
10773
10774 {
10775 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10776 if err != nil {
10777 return err
10778 }
10779
10780 t.CreatedAt = string(sval)
10781 }
10782 // t.Description (string) (string)
10783 case "description":
10784
10785 {
10786 b, err := cr.ReadByte()
10787 if err != nil {
10788 return err
10789 }
10790 if b != cbg.CborNull[0] {
10791 if err := cr.UnreadByte(); err != nil {
10792 return err
10793 }
10794
10795 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10796 if err != nil {
10797 return err
10798 }
10799
10800 t.Description = (*string)(&sval)
10801 }
10802 }
10803
10804 default:
10805 // Field doesn't exist on this type, so ignore it
10806 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
10807 return err
10808 }
10809 }
10810 }
10811
10812 return nil
10813}
10814func (t *RepoArtifact) MarshalCBOR(w io.Writer) error {
10815 if t == nil {
10816 _, err := w.Write(cbg.CborNull)
10817 return err
10818 }
10819
10820 cw := cbg.NewCborWriter(w)
10821 fieldCount := 7
10822
10823 if t.Repo == nil {
10824 fieldCount--
10825 }
10826
10827 if t.RepoDid == nil {
10828 fieldCount--
10829 }
10830
10831 if t.Tag == nil {
10832 fieldCount--
10833 }
10834
10835 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
10836 return err
10837 }
10838
10839 // t.Tag (util.LexBytes) (slice)
10840 if t.Tag != nil {
10841
10842 if len("tag") > 1000000 {
10843 return xerrors.Errorf("Value in field \"tag\" was too long")
10844 }
10845
10846 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tag"))); err != nil {
10847 return err
10848 }
10849 if _, err := cw.WriteString(string("tag")); err != nil {
10850 return err
10851 }
10852
10853 if len(t.Tag) > 2097152 {
10854 return xerrors.Errorf("Byte array in field t.Tag was too long")
10855 }
10856
10857 if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Tag))); err != nil {
10858 return err
10859 }
10860
10861 if _, err := cw.Write(t.Tag); err != nil {
10862 return err
10863 }
10864
10865 }
10866
10867 // t.Name (string) (string)
10868 if len("name") > 1000000 {
10869 return xerrors.Errorf("Value in field \"name\" was too long")
10870 }
10871
10872 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
10873 return err
10874 }
10875 if _, err := cw.WriteString(string("name")); err != nil {
10876 return err
10877 }
10878
10879 if len(t.Name) > 1000000 {
10880 return xerrors.Errorf("Value in field t.Name was too long")
10881 }
10882
10883 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
10884 return err
10885 }
10886 if _, err := cw.WriteString(string(t.Name)); err != nil {
10887 return err
10888 }
10889
10890 // t.Repo (string) (string)
10891 if t.Repo != nil {
10892
10893 if len("repo") > 1000000 {
10894 return xerrors.Errorf("Value in field \"repo\" was too long")
10895 }
10896
10897 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
10898 return err
10899 }
10900 if _, err := cw.WriteString(string("repo")); err != nil {
10901 return err
10902 }
10903
10904 if t.Repo == nil {
10905 if _, err := cw.Write(cbg.CborNull); err != nil {
10906 return err
10907 }
10908 } else {
10909 if len(*t.Repo) > 1000000 {
10910 return xerrors.Errorf("Value in field t.Repo was too long")
10911 }
10912
10913 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
10914 return err
10915 }
10916 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
10917 return err
10918 }
10919 }
10920 }
10921
10922 // t.LexiconTypeID (string) (string)
10923 if len("$type") > 1000000 {
10924 return xerrors.Errorf("Value in field \"$type\" was too long")
10925 }
10926
10927 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
10928 return err
10929 }
10930 if _, err := cw.WriteString(string("$type")); err != nil {
10931 return err
10932 }
10933
10934 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.artifact"))); err != nil {
10935 return err
10936 }
10937 if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil {
10938 return err
10939 }
10940
10941 // t.RepoDid (string) (string)
10942 if t.RepoDid != nil {
10943
10944 if len("repoDid") > 1000000 {
10945 return xerrors.Errorf("Value in field \"repoDid\" was too long")
10946 }
10947
10948 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
10949 return err
10950 }
10951 if _, err := cw.WriteString(string("repoDid")); err != nil {
10952 return err
10953 }
10954
10955 if t.RepoDid == nil {
10956 if _, err := cw.Write(cbg.CborNull); err != nil {
10957 return err
10958 }
10959 } else {
10960 if len(*t.RepoDid) > 1000000 {
10961 return xerrors.Errorf("Value in field t.RepoDid was too long")
10962 }
10963
10964 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil {
10965 return err
10966 }
10967 if _, err := cw.WriteString(string(*t.RepoDid)); err != nil {
10968 return err
10969 }
10970 }
10971 }
10972
10973 // t.Artifact (util.LexBlob) (struct)
10974 if len("artifact") > 1000000 {
10975 return xerrors.Errorf("Value in field \"artifact\" was too long")
10976 }
10977
10978 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("artifact"))); err != nil {
10979 return err
10980 }
10981 if _, err := cw.WriteString(string("artifact")); err != nil {
10982 return err
10983 }
10984
10985 if err := t.Artifact.MarshalCBOR(cw); err != nil {
10986 return err
10987 }
10988
10989 // t.CreatedAt (string) (string)
10990 if len("createdAt") > 1000000 {
10991 return xerrors.Errorf("Value in field \"createdAt\" was too long")
10992 }
10993
10994 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
10995 return err
10996 }
10997 if _, err := cw.WriteString(string("createdAt")); err != nil {
10998 return err
10999 }
11000
11001 if len(t.CreatedAt) > 1000000 {
11002 return xerrors.Errorf("Value in field t.CreatedAt was too long")
11003 }
11004
11005 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
11006 return err
11007 }
11008 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
11009 return err
11010 }
11011 return nil
11012}
11013
11014func (t *RepoArtifact) UnmarshalCBOR(r io.Reader) (err error) {
11015 *t = RepoArtifact{}
11016
11017 cr := cbg.NewCborReader(r)
11018
11019 maj, extra, err := cr.ReadHeader()
11020 if err != nil {
11021 return err
11022 }
11023 defer func() {
11024 if err == io.EOF {
11025 err = io.ErrUnexpectedEOF
11026 }
11027 }()
11028
11029 if maj != cbg.MajMap {
11030 return fmt.Errorf("cbor input should be of type map")
11031 }
11032
11033 if extra > cbg.MaxLength {
11034 return fmt.Errorf("RepoArtifact: map struct too large (%d)", extra)
11035 }
11036
11037 n := extra
11038
11039 nameBuf := make([]byte, 9)
11040 for i := uint64(0); i < n; i++ {
11041 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
11042 if err != nil {
11043 return err
11044 }
11045
11046 if !ok {
11047 // Field doesn't exist on this type, so ignore it
11048 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
11049 return err
11050 }
11051 continue
11052 }
11053
11054 switch string(nameBuf[:nameLen]) {
11055 // t.Tag (util.LexBytes) (slice)
11056 case "tag":
11057
11058 maj, extra, err = cr.ReadHeader()
11059 if err != nil {
11060 return err
11061 }
11062
11063 if extra > 2097152 {
11064 return fmt.Errorf("t.Tag: byte array too large (%d)", extra)
11065 }
11066 if maj != cbg.MajByteString {
11067 return fmt.Errorf("expected byte array")
11068 }
11069
11070 if extra > 0 {
11071 t.Tag = make([]uint8, extra)
11072 }
11073
11074 if _, err := io.ReadFull(cr, t.Tag); err != nil {
11075 return err
11076 }
11077
11078 // t.Name (string) (string)
11079 case "name":
11080
11081 {
11082 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11083 if err != nil {
11084 return err
11085 }
11086
11087 t.Name = string(sval)
11088 }
11089 // t.Repo (string) (string)
11090 case "repo":
11091
11092 {
11093 b, err := cr.ReadByte()
11094 if err != nil {
11095 return err
11096 }
11097 if b != cbg.CborNull[0] {
11098 if err := cr.UnreadByte(); err != nil {
11099 return err
11100 }
11101
11102 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11103 if err != nil {
11104 return err
11105 }
11106
11107 t.Repo = (*string)(&sval)
11108 }
11109 }
11110 // t.LexiconTypeID (string) (string)
11111 case "$type":
11112
11113 {
11114 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11115 if err != nil {
11116 return err
11117 }
11118
11119 t.LexiconTypeID = string(sval)
11120 }
11121 // t.RepoDid (string) (string)
11122 case "repoDid":
11123
11124 {
11125 b, err := cr.ReadByte()
11126 if err != nil {
11127 return err
11128 }
11129 if b != cbg.CborNull[0] {
11130 if err := cr.UnreadByte(); err != nil {
11131 return err
11132 }
11133
11134 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11135 if err != nil {
11136 return err
11137 }
11138
11139 t.RepoDid = (*string)(&sval)
11140 }
11141 }
11142 // t.Artifact (util.LexBlob) (struct)
11143 case "artifact":
11144
11145 {
11146
11147 b, err := cr.ReadByte()
11148 if err != nil {
11149 return err
11150 }
11151 if b != cbg.CborNull[0] {
11152 if err := cr.UnreadByte(); err != nil {
11153 return err
11154 }
11155 t.Artifact = new(util.LexBlob)
11156 if err := t.Artifact.UnmarshalCBOR(cr); err != nil {
11157 return xerrors.Errorf("unmarshaling t.Artifact pointer: %w", err)
11158 }
11159 }
11160
11161 }
11162 // t.CreatedAt (string) (string)
11163 case "createdAt":
11164
11165 {
11166 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11167 if err != nil {
11168 return err
11169 }
11170
11171 t.CreatedAt = string(sval)
11172 }
11173
11174 default:
11175 // Field doesn't exist on this type, so ignore it
11176 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
11177 return err
11178 }
11179 }
11180 }
11181
11182 return nil
11183}
11184func (t *RepoCollaborator) MarshalCBOR(w io.Writer) error {
11185 if t == nil {
11186 _, err := w.Write(cbg.CborNull)
11187 return err
11188 }
11189
11190 cw := cbg.NewCborWriter(w)
11191
11192 if _, err := cw.Write([]byte{164}); err != nil {
11193 return err
11194 }
11195
11196 // t.Repo (string) (string)
11197 if len("repo") > 1000000 {
11198 return xerrors.Errorf("Value in field \"repo\" was too long")
11199 }
11200
11201 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
11202 return err
11203 }
11204 if _, err := cw.WriteString(string("repo")); err != nil {
11205 return err
11206 }
11207
11208 if len(t.Repo) > 1000000 {
11209 return xerrors.Errorf("Value in field t.Repo was too long")
11210 }
11211
11212 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
11213 return err
11214 }
11215 if _, err := cw.WriteString(string(t.Repo)); err != nil {
11216 return err
11217 }
11218
11219 // t.LexiconTypeID (string) (string)
11220 if len("$type") > 1000000 {
11221 return xerrors.Errorf("Value in field \"$type\" was too long")
11222 }
11223
11224 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
11225 return err
11226 }
11227 if _, err := cw.WriteString(string("$type")); err != nil {
11228 return err
11229 }
11230
11231 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.collaborator"))); err != nil {
11232 return err
11233 }
11234 if _, err := cw.WriteString(string("sh.tangled.repo.collaborator")); err != nil {
11235 return err
11236 }
11237
11238 // t.Subject (string) (string)
11239 if len("subject") > 1000000 {
11240 return xerrors.Errorf("Value in field \"subject\" was too long")
11241 }
11242
11243 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
11244 return err
11245 }
11246 if _, err := cw.WriteString(string("subject")); err != nil {
11247 return err
11248 }
11249
11250 if len(t.Subject) > 1000000 {
11251 return xerrors.Errorf("Value in field t.Subject was too long")
11252 }
11253
11254 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
11255 return err
11256 }
11257 if _, err := cw.WriteString(string(t.Subject)); err != nil {
11258 return err
11259 }
11260
11261 // t.CreatedAt (string) (string)
11262 if len("createdAt") > 1000000 {
11263 return xerrors.Errorf("Value in field \"createdAt\" was too long")
11264 }
11265
11266 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
11267 return err
11268 }
11269 if _, err := cw.WriteString(string("createdAt")); err != nil {
11270 return err
11271 }
11272
11273 if len(t.CreatedAt) > 1000000 {
11274 return xerrors.Errorf("Value in field t.CreatedAt was too long")
11275 }
11276
11277 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
11278 return err
11279 }
11280 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
11281 return err
11282 }
11283 return nil
11284}
11285
11286func (t *RepoCollaborator) UnmarshalCBOR(r io.Reader) (err error) {
11287 *t = RepoCollaborator{}
11288
11289 cr := cbg.NewCborReader(r)
11290
11291 maj, extra, err := cr.ReadHeader()
11292 if err != nil {
11293 return err
11294 }
11295 defer func() {
11296 if err == io.EOF {
11297 err = io.ErrUnexpectedEOF
11298 }
11299 }()
11300
11301 if maj != cbg.MajMap {
11302 return fmt.Errorf("cbor input should be of type map")
11303 }
11304
11305 if extra > cbg.MaxLength {
11306 return fmt.Errorf("RepoCollaborator: map struct too large (%d)", extra)
11307 }
11308
11309 n := extra
11310
11311 nameBuf := make([]byte, 9)
11312 for i := uint64(0); i < n; i++ {
11313 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
11314 if err != nil {
11315 return err
11316 }
11317
11318 if !ok {
11319 // Field doesn't exist on this type, so ignore it
11320 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
11321 return err
11322 }
11323 continue
11324 }
11325
11326 switch string(nameBuf[:nameLen]) {
11327 // t.Repo (string) (string)
11328 case "repo":
11329
11330 {
11331 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11332 if err != nil {
11333 return err
11334 }
11335
11336 t.Repo = string(sval)
11337 }
11338 // t.LexiconTypeID (string) (string)
11339 case "$type":
11340
11341 {
11342 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11343 if err != nil {
11344 return err
11345 }
11346
11347 t.LexiconTypeID = string(sval)
11348 }
11349 // t.Subject (string) (string)
11350 case "subject":
11351
11352 {
11353 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11354 if err != nil {
11355 return err
11356 }
11357
11358 t.Subject = string(sval)
11359 }
11360 // t.CreatedAt (string) (string)
11361 case "createdAt":
11362
11363 {
11364 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11365 if err != nil {
11366 return err
11367 }
11368
11369 t.CreatedAt = string(sval)
11370 }
11371
11372 default:
11373 // Field doesn't exist on this type, so ignore it
11374 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
11375 return err
11376 }
11377 }
11378 }
11379
11380 return nil
11381}
11382func (t *RepoIssue) MarshalCBOR(w io.Writer) error {
11383 if t == nil {
11384 _, err := w.Write(cbg.CborNull)
11385 return err
11386 }
11387
11388 cw := cbg.NewCborWriter(w)
11389 fieldCount := 7
11390
11391 if t.Body == nil {
11392 fieldCount--
11393 }
11394
11395 if t.Mentions == nil {
11396 fieldCount--
11397 }
11398
11399 if t.References == nil {
11400 fieldCount--
11401 }
11402
11403 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
11404 return err
11405 }
11406
11407 // t.Body (string) (string)
11408 if t.Body != nil {
11409
11410 if len("body") > 1000000 {
11411 return xerrors.Errorf("Value in field \"body\" was too long")
11412 }
11413
11414 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
11415 return err
11416 }
11417 if _, err := cw.WriteString(string("body")); err != nil {
11418 return err
11419 }
11420
11421 if t.Body == nil {
11422 if _, err := cw.Write(cbg.CborNull); err != nil {
11423 return err
11424 }
11425 } else {
11426 if len(*t.Body) > 1000000 {
11427 return xerrors.Errorf("Value in field t.Body was too long")
11428 }
11429
11430 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
11431 return err
11432 }
11433 if _, err := cw.WriteString(string(*t.Body)); err != nil {
11434 return err
11435 }
11436 }
11437 }
11438
11439 // t.Repo (string) (string)
11440 if len("repo") > 1000000 {
11441 return xerrors.Errorf("Value in field \"repo\" was too long")
11442 }
11443
11444 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
11445 return err
11446 }
11447 if _, err := cw.WriteString(string("repo")); err != nil {
11448 return err
11449 }
11450
11451 if len(t.Repo) > 1000000 {
11452 return xerrors.Errorf("Value in field t.Repo was too long")
11453 }
11454
11455 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
11456 return err
11457 }
11458 if _, err := cw.WriteString(string(t.Repo)); err != nil {
11459 return err
11460 }
11461
11462 // t.LexiconTypeID (string) (string)
11463 if len("$type") > 1000000 {
11464 return xerrors.Errorf("Value in field \"$type\" was too long")
11465 }
11466
11467 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
11468 return err
11469 }
11470 if _, err := cw.WriteString(string("$type")); err != nil {
11471 return err
11472 }
11473
11474 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil {
11475 return err
11476 }
11477 if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil {
11478 return err
11479 }
11480
11481 // t.Title (string) (string)
11482 if len("title") > 1000000 {
11483 return xerrors.Errorf("Value in field \"title\" was too long")
11484 }
11485
11486 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
11487 return err
11488 }
11489 if _, err := cw.WriteString(string("title")); err != nil {
11490 return err
11491 }
11492
11493 if len(t.Title) > 1000000 {
11494 return xerrors.Errorf("Value in field t.Title was too long")
11495 }
11496
11497 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
11498 return err
11499 }
11500 if _, err := cw.WriteString(string(t.Title)); err != nil {
11501 return err
11502 }
11503
11504 // t.Mentions ([]string) (slice)
11505 if t.Mentions != nil {
11506
11507 if len("mentions") > 1000000 {
11508 return xerrors.Errorf("Value in field \"mentions\" was too long")
11509 }
11510
11511 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
11512 return err
11513 }
11514 if _, err := cw.WriteString(string("mentions")); err != nil {
11515 return err
11516 }
11517
11518 if len(t.Mentions) > 8192 {
11519 return xerrors.Errorf("Slice value in field t.Mentions was too long")
11520 }
11521
11522 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
11523 return err
11524 }
11525 for _, v := range t.Mentions {
11526 if len(v) > 1000000 {
11527 return xerrors.Errorf("Value in field v was too long")
11528 }
11529
11530 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
11531 return err
11532 }
11533 if _, err := cw.WriteString(string(v)); err != nil {
11534 return err
11535 }
11536
11537 }
11538 }
11539
11540 // t.CreatedAt (string) (string)
11541 if len("createdAt") > 1000000 {
11542 return xerrors.Errorf("Value in field \"createdAt\" was too long")
11543 }
11544
11545 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
11546 return err
11547 }
11548 if _, err := cw.WriteString(string("createdAt")); err != nil {
11549 return err
11550 }
11551
11552 if len(t.CreatedAt) > 1000000 {
11553 return xerrors.Errorf("Value in field t.CreatedAt was too long")
11554 }
11555
11556 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
11557 return err
11558 }
11559 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
11560 return err
11561 }
11562
11563 // t.References ([]string) (slice)
11564 if t.References != nil {
11565
11566 if len("references") > 1000000 {
11567 return xerrors.Errorf("Value in field \"references\" was too long")
11568 }
11569
11570 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
11571 return err
11572 }
11573 if _, err := cw.WriteString(string("references")); err != nil {
11574 return err
11575 }
11576
11577 if len(t.References) > 8192 {
11578 return xerrors.Errorf("Slice value in field t.References was too long")
11579 }
11580
11581 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
11582 return err
11583 }
11584 for _, v := range t.References {
11585 if len(v) > 1000000 {
11586 return xerrors.Errorf("Value in field v was too long")
11587 }
11588
11589 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
11590 return err
11591 }
11592 if _, err := cw.WriteString(string(v)); err != nil {
11593 return err
11594 }
11595
11596 }
11597 }
11598 return nil
11599}
11600
11601func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) {
11602 *t = RepoIssue{}
11603
11604 cr := cbg.NewCborReader(r)
11605
11606 maj, extra, err := cr.ReadHeader()
11607 if err != nil {
11608 return err
11609 }
11610 defer func() {
11611 if err == io.EOF {
11612 err = io.ErrUnexpectedEOF
11613 }
11614 }()
11615
11616 if maj != cbg.MajMap {
11617 return fmt.Errorf("cbor input should be of type map")
11618 }
11619
11620 if extra > cbg.MaxLength {
11621 return fmt.Errorf("RepoIssue: map struct too large (%d)", extra)
11622 }
11623
11624 n := extra
11625
11626 nameBuf := make([]byte, 10)
11627 for i := uint64(0); i < n; i++ {
11628 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
11629 if err != nil {
11630 return err
11631 }
11632
11633 if !ok {
11634 // Field doesn't exist on this type, so ignore it
11635 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
11636 return err
11637 }
11638 continue
11639 }
11640
11641 switch string(nameBuf[:nameLen]) {
11642 // t.Body (string) (string)
11643 case "body":
11644
11645 {
11646 b, err := cr.ReadByte()
11647 if err != nil {
11648 return err
11649 }
11650 if b != cbg.CborNull[0] {
11651 if err := cr.UnreadByte(); err != nil {
11652 return err
11653 }
11654
11655 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11656 if err != nil {
11657 return err
11658 }
11659
11660 t.Body = (*string)(&sval)
11661 }
11662 }
11663 // t.Repo (string) (string)
11664 case "repo":
11665
11666 {
11667 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11668 if err != nil {
11669 return err
11670 }
11671
11672 t.Repo = string(sval)
11673 }
11674 // t.LexiconTypeID (string) (string)
11675 case "$type":
11676
11677 {
11678 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11679 if err != nil {
11680 return err
11681 }
11682
11683 t.LexiconTypeID = string(sval)
11684 }
11685 // t.Title (string) (string)
11686 case "title":
11687
11688 {
11689 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11690 if err != nil {
11691 return err
11692 }
11693
11694 t.Title = string(sval)
11695 }
11696 // t.Mentions ([]string) (slice)
11697 case "mentions":
11698
11699 maj, extra, err = cr.ReadHeader()
11700 if err != nil {
11701 return err
11702 }
11703
11704 if extra > 8192 {
11705 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
11706 }
11707
11708 if maj != cbg.MajArray {
11709 return fmt.Errorf("expected cbor array")
11710 }
11711
11712 if extra > 0 {
11713 t.Mentions = make([]string, extra)
11714 }
11715
11716 for i := 0; i < int(extra); i++ {
11717 {
11718 var maj byte
11719 var extra uint64
11720 var err error
11721 _ = maj
11722 _ = extra
11723 _ = err
11724
11725 {
11726 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11727 if err != nil {
11728 return err
11729 }
11730
11731 t.Mentions[i] = string(sval)
11732 }
11733
11734 }
11735 }
11736 // t.CreatedAt (string) (string)
11737 case "createdAt":
11738
11739 {
11740 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11741 if err != nil {
11742 return err
11743 }
11744
11745 t.CreatedAt = string(sval)
11746 }
11747 // t.References ([]string) (slice)
11748 case "references":
11749
11750 maj, extra, err = cr.ReadHeader()
11751 if err != nil {
11752 return err
11753 }
11754
11755 if extra > 8192 {
11756 return fmt.Errorf("t.References: array too large (%d)", extra)
11757 }
11758
11759 if maj != cbg.MajArray {
11760 return fmt.Errorf("expected cbor array")
11761 }
11762
11763 if extra > 0 {
11764 t.References = make([]string, extra)
11765 }
11766
11767 for i := 0; i < int(extra); i++ {
11768 {
11769 var maj byte
11770 var extra uint64
11771 var err error
11772 _ = maj
11773 _ = extra
11774 _ = err
11775
11776 {
11777 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11778 if err != nil {
11779 return err
11780 }
11781
11782 t.References[i] = string(sval)
11783 }
11784
11785 }
11786 }
11787
11788 default:
11789 // Field doesn't exist on this type, so ignore it
11790 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
11791 return err
11792 }
11793 }
11794 }
11795
11796 return nil
11797}
11798func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error {
11799 if t == nil {
11800 _, err := w.Write(cbg.CborNull)
11801 return err
11802 }
11803
11804 cw := cbg.NewCborWriter(w)
11805 fieldCount := 7
11806
11807 if t.Mentions == nil {
11808 fieldCount--
11809 }
11810
11811 if t.References == nil {
11812 fieldCount--
11813 }
11814
11815 if t.ReplyTo == nil {
11816 fieldCount--
11817 }
11818
11819 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
11820 return err
11821 }
11822
11823 // t.Body (string) (string)
11824 if len("body") > 1000000 {
11825 return xerrors.Errorf("Value in field \"body\" was too long")
11826 }
11827
11828 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
11829 return err
11830 }
11831 if _, err := cw.WriteString(string("body")); err != nil {
11832 return err
11833 }
11834
11835 if len(t.Body) > 1000000 {
11836 return xerrors.Errorf("Value in field t.Body was too long")
11837 }
11838
11839 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
11840 return err
11841 }
11842 if _, err := cw.WriteString(string(t.Body)); err != nil {
11843 return err
11844 }
11845
11846 // t.LexiconTypeID (string) (string)
11847 if len("$type") > 1000000 {
11848 return xerrors.Errorf("Value in field \"$type\" was too long")
11849 }
11850
11851 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
11852 return err
11853 }
11854 if _, err := cw.WriteString(string("$type")); err != nil {
11855 return err
11856 }
11857
11858 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil {
11859 return err
11860 }
11861 if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil {
11862 return err
11863 }
11864
11865 // t.Issue (string) (string)
11866 if len("issue") > 1000000 {
11867 return xerrors.Errorf("Value in field \"issue\" was too long")
11868 }
11869
11870 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
11871 return err
11872 }
11873 if _, err := cw.WriteString(string("issue")); err != nil {
11874 return err
11875 }
11876
11877 if len(t.Issue) > 1000000 {
11878 return xerrors.Errorf("Value in field t.Issue was too long")
11879 }
11880
11881 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
11882 return err
11883 }
11884 if _, err := cw.WriteString(string(t.Issue)); err != nil {
11885 return err
11886 }
11887
11888 // t.ReplyTo (string) (string)
11889 if t.ReplyTo != nil {
11890
11891 if len("replyTo") > 1000000 {
11892 return xerrors.Errorf("Value in field \"replyTo\" was too long")
11893 }
11894
11895 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("replyTo"))); err != nil {
11896 return err
11897 }
11898 if _, err := cw.WriteString(string("replyTo")); err != nil {
11899 return err
11900 }
11901
11902 if t.ReplyTo == nil {
11903 if _, err := cw.Write(cbg.CborNull); err != nil {
11904 return err
11905 }
11906 } else {
11907 if len(*t.ReplyTo) > 1000000 {
11908 return xerrors.Errorf("Value in field t.ReplyTo was too long")
11909 }
11910
11911 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ReplyTo))); err != nil {
11912 return err
11913 }
11914 if _, err := cw.WriteString(string(*t.ReplyTo)); err != nil {
11915 return err
11916 }
11917 }
11918 }
11919
11920 // t.Mentions ([]string) (slice)
11921 if t.Mentions != nil {
11922
11923 if len("mentions") > 1000000 {
11924 return xerrors.Errorf("Value in field \"mentions\" was too long")
11925 }
11926
11927 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
11928 return err
11929 }
11930 if _, err := cw.WriteString(string("mentions")); err != nil {
11931 return err
11932 }
11933
11934 if len(t.Mentions) > 8192 {
11935 return xerrors.Errorf("Slice value in field t.Mentions was too long")
11936 }
11937
11938 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
11939 return err
11940 }
11941 for _, v := range t.Mentions {
11942 if len(v) > 1000000 {
11943 return xerrors.Errorf("Value in field v was too long")
11944 }
11945
11946 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
11947 return err
11948 }
11949 if _, err := cw.WriteString(string(v)); err != nil {
11950 return err
11951 }
11952
11953 }
11954 }
11955
11956 // t.CreatedAt (string) (string)
11957 if len("createdAt") > 1000000 {
11958 return xerrors.Errorf("Value in field \"createdAt\" was too long")
11959 }
11960
11961 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
11962 return err
11963 }
11964 if _, err := cw.WriteString(string("createdAt")); err != nil {
11965 return err
11966 }
11967
11968 if len(t.CreatedAt) > 1000000 {
11969 return xerrors.Errorf("Value in field t.CreatedAt was too long")
11970 }
11971
11972 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
11973 return err
11974 }
11975 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
11976 return err
11977 }
11978
11979 // t.References ([]string) (slice)
11980 if t.References != nil {
11981
11982 if len("references") > 1000000 {
11983 return xerrors.Errorf("Value in field \"references\" was too long")
11984 }
11985
11986 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
11987 return err
11988 }
11989 if _, err := cw.WriteString(string("references")); err != nil {
11990 return err
11991 }
11992
11993 if len(t.References) > 8192 {
11994 return xerrors.Errorf("Slice value in field t.References was too long")
11995 }
11996
11997 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
11998 return err
11999 }
12000 for _, v := range t.References {
12001 if len(v) > 1000000 {
12002 return xerrors.Errorf("Value in field v was too long")
12003 }
12004
12005 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
12006 return err
12007 }
12008 if _, err := cw.WriteString(string(v)); err != nil {
12009 return err
12010 }
12011
12012 }
12013 }
12014 return nil
12015}
12016
12017func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) {
12018 *t = RepoIssueComment{}
12019
12020 cr := cbg.NewCborReader(r)
12021
12022 maj, extra, err := cr.ReadHeader()
12023 if err != nil {
12024 return err
12025 }
12026 defer func() {
12027 if err == io.EOF {
12028 err = io.ErrUnexpectedEOF
12029 }
12030 }()
12031
12032 if maj != cbg.MajMap {
12033 return fmt.Errorf("cbor input should be of type map")
12034 }
12035
12036 if extra > cbg.MaxLength {
12037 return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra)
12038 }
12039
12040 n := extra
12041
12042 nameBuf := make([]byte, 10)
12043 for i := uint64(0); i < n; i++ {
12044 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
12045 if err != nil {
12046 return err
12047 }
12048
12049 if !ok {
12050 // Field doesn't exist on this type, so ignore it
12051 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
12052 return err
12053 }
12054 continue
12055 }
12056
12057 switch string(nameBuf[:nameLen]) {
12058 // t.Body (string) (string)
12059 case "body":
12060
12061 {
12062 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12063 if err != nil {
12064 return err
12065 }
12066
12067 t.Body = string(sval)
12068 }
12069 // t.LexiconTypeID (string) (string)
12070 case "$type":
12071
12072 {
12073 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12074 if err != nil {
12075 return err
12076 }
12077
12078 t.LexiconTypeID = string(sval)
12079 }
12080 // t.Issue (string) (string)
12081 case "issue":
12082
12083 {
12084 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12085 if err != nil {
12086 return err
12087 }
12088
12089 t.Issue = string(sval)
12090 }
12091 // t.ReplyTo (string) (string)
12092 case "replyTo":
12093
12094 {
12095 b, err := cr.ReadByte()
12096 if err != nil {
12097 return err
12098 }
12099 if b != cbg.CborNull[0] {
12100 if err := cr.UnreadByte(); err != nil {
12101 return err
12102 }
12103
12104 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12105 if err != nil {
12106 return err
12107 }
12108
12109 t.ReplyTo = (*string)(&sval)
12110 }
12111 }
12112 // t.Mentions ([]string) (slice)
12113 case "mentions":
12114
12115 maj, extra, err = cr.ReadHeader()
12116 if err != nil {
12117 return err
12118 }
12119
12120 if extra > 8192 {
12121 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
12122 }
12123
12124 if maj != cbg.MajArray {
12125 return fmt.Errorf("expected cbor array")
12126 }
12127
12128 if extra > 0 {
12129 t.Mentions = make([]string, extra)
12130 }
12131
12132 for i := 0; i < int(extra); i++ {
12133 {
12134 var maj byte
12135 var extra uint64
12136 var err error
12137 _ = maj
12138 _ = extra
12139 _ = err
12140
12141 {
12142 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12143 if err != nil {
12144 return err
12145 }
12146
12147 t.Mentions[i] = string(sval)
12148 }
12149
12150 }
12151 }
12152 // t.CreatedAt (string) (string)
12153 case "createdAt":
12154
12155 {
12156 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12157 if err != nil {
12158 return err
12159 }
12160
12161 t.CreatedAt = string(sval)
12162 }
12163 // t.References ([]string) (slice)
12164 case "references":
12165
12166 maj, extra, err = cr.ReadHeader()
12167 if err != nil {
12168 return err
12169 }
12170
12171 if extra > 8192 {
12172 return fmt.Errorf("t.References: array too large (%d)", extra)
12173 }
12174
12175 if maj != cbg.MajArray {
12176 return fmt.Errorf("expected cbor array")
12177 }
12178
12179 if extra > 0 {
12180 t.References = make([]string, extra)
12181 }
12182
12183 for i := 0; i < int(extra); i++ {
12184 {
12185 var maj byte
12186 var extra uint64
12187 var err error
12188 _ = maj
12189 _ = extra
12190 _ = err
12191
12192 {
12193 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12194 if err != nil {
12195 return err
12196 }
12197
12198 t.References[i] = string(sval)
12199 }
12200
12201 }
12202 }
12203
12204 default:
12205 // Field doesn't exist on this type, so ignore it
12206 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
12207 return err
12208 }
12209 }
12210 }
12211
12212 return nil
12213}
12214func (t *RepoIssueState) MarshalCBOR(w io.Writer) error {
12215 if t == nil {
12216 _, err := w.Write(cbg.CborNull)
12217 return err
12218 }
12219
12220 cw := cbg.NewCborWriter(w)
12221
12222 if _, err := cw.Write([]byte{164}); err != nil {
12223 return err
12224 }
12225
12226 // t.LexiconTypeID (string) (string)
12227 if len("$type") > 1000000 {
12228 return xerrors.Errorf("Value in field \"$type\" was too long")
12229 }
12230
12231 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
12232 return err
12233 }
12234 if _, err := cw.WriteString(string("$type")); err != nil {
12235 return err
12236 }
12237
12238 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil {
12239 return err
12240 }
12241 if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil {
12242 return err
12243 }
12244
12245 // t.Issue (string) (string)
12246 if len("issue") > 1000000 {
12247 return xerrors.Errorf("Value in field \"issue\" was too long")
12248 }
12249
12250 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
12251 return err
12252 }
12253 if _, err := cw.WriteString(string("issue")); err != nil {
12254 return err
12255 }
12256
12257 if len(t.Issue) > 1000000 {
12258 return xerrors.Errorf("Value in field t.Issue was too long")
12259 }
12260
12261 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
12262 return err
12263 }
12264 if _, err := cw.WriteString(string(t.Issue)); err != nil {
12265 return err
12266 }
12267
12268 // t.State (string) (string)
12269 if len("state") > 1000000 {
12270 return xerrors.Errorf("Value in field \"state\" was too long")
12271 }
12272
12273 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil {
12274 return err
12275 }
12276 if _, err := cw.WriteString(string("state")); err != nil {
12277 return err
12278 }
12279
12280 if len(t.State) > 1000000 {
12281 return xerrors.Errorf("Value in field t.State was too long")
12282 }
12283
12284 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil {
12285 return err
12286 }
12287 if _, err := cw.WriteString(string(t.State)); err != nil {
12288 return err
12289 }
12290
12291 // t.CreatedAt (string) (string)
12292 if len("createdAt") > 1000000 {
12293 return xerrors.Errorf("Value in field \"createdAt\" was too long")
12294 }
12295
12296 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
12297 return err
12298 }
12299 if _, err := cw.WriteString(string("createdAt")); err != nil {
12300 return err
12301 }
12302
12303 if len(t.CreatedAt) > 1000000 {
12304 return xerrors.Errorf("Value in field t.CreatedAt was too long")
12305 }
12306
12307 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
12308 return err
12309 }
12310 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
12311 return err
12312 }
12313 return nil
12314}
12315
12316func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) {
12317 *t = RepoIssueState{}
12318
12319 cr := cbg.NewCborReader(r)
12320
12321 maj, extra, err := cr.ReadHeader()
12322 if err != nil {
12323 return err
12324 }
12325 defer func() {
12326 if err == io.EOF {
12327 err = io.ErrUnexpectedEOF
12328 }
12329 }()
12330
12331 if maj != cbg.MajMap {
12332 return fmt.Errorf("cbor input should be of type map")
12333 }
12334
12335 if extra > cbg.MaxLength {
12336 return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra)
12337 }
12338
12339 n := extra
12340
12341 nameBuf := make([]byte, 9)
12342 for i := uint64(0); i < n; i++ {
12343 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
12344 if err != nil {
12345 return err
12346 }
12347
12348 if !ok {
12349 // Field doesn't exist on this type, so ignore it
12350 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
12351 return err
12352 }
12353 continue
12354 }
12355
12356 switch string(nameBuf[:nameLen]) {
12357 // t.LexiconTypeID (string) (string)
12358 case "$type":
12359
12360 {
12361 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12362 if err != nil {
12363 return err
12364 }
12365
12366 t.LexiconTypeID = string(sval)
12367 }
12368 // t.Issue (string) (string)
12369 case "issue":
12370
12371 {
12372 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12373 if err != nil {
12374 return err
12375 }
12376
12377 t.Issue = string(sval)
12378 }
12379 // t.State (string) (string)
12380 case "state":
12381
12382 {
12383 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12384 if err != nil {
12385 return err
12386 }
12387
12388 t.State = string(sval)
12389 }
12390 // t.CreatedAt (string) (string)
12391 case "createdAt":
12392
12393 {
12394 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12395 if err != nil {
12396 return err
12397 }
12398
12399 t.CreatedAt = string(sval)
12400 }
12401
12402 default:
12403 // Field doesn't exist on this type, so ignore it
12404 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
12405 return err
12406 }
12407 }
12408 }
12409
12410 return nil
12411}
12412func (t *RepoPull) MarshalCBOR(w io.Writer) error {
12413 if t == nil {
12414 _, err := w.Write(cbg.CborNull)
12415 return err
12416 }
12417
12418 cw := cbg.NewCborWriter(w)
12419 fieldCount := 10
12420
12421 if t.Body == nil {
12422 fieldCount--
12423 }
12424
12425 if t.DependentOn == nil {
12426 fieldCount--
12427 }
12428
12429 if t.Mentions == nil {
12430 fieldCount--
12431 }
12432
12433 if t.References == nil {
12434 fieldCount--
12435 }
12436
12437 if t.Source == nil {
12438 fieldCount--
12439 }
12440
12441 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
12442 return err
12443 }
12444
12445 // t.Body (string) (string)
12446 if t.Body != nil {
12447
12448 if len("body") > 1000000 {
12449 return xerrors.Errorf("Value in field \"body\" was too long")
12450 }
12451
12452 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
12453 return err
12454 }
12455 if _, err := cw.WriteString(string("body")); err != nil {
12456 return err
12457 }
12458
12459 if t.Body == nil {
12460 if _, err := cw.Write(cbg.CborNull); err != nil {
12461 return err
12462 }
12463 } else {
12464 if len(*t.Body) > 1000000 {
12465 return xerrors.Errorf("Value in field t.Body was too long")
12466 }
12467
12468 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
12469 return err
12470 }
12471 if _, err := cw.WriteString(string(*t.Body)); err != nil {
12472 return err
12473 }
12474 }
12475 }
12476
12477 // t.LexiconTypeID (string) (string)
12478 if len("$type") > 1000000 {
12479 return xerrors.Errorf("Value in field \"$type\" was too long")
12480 }
12481
12482 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
12483 return err
12484 }
12485 if _, err := cw.WriteString(string("$type")); err != nil {
12486 return err
12487 }
12488
12489 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil {
12490 return err
12491 }
12492 if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil {
12493 return err
12494 }
12495
12496 // t.Title (string) (string)
12497 if len("title") > 1000000 {
12498 return xerrors.Errorf("Value in field \"title\" was too long")
12499 }
12500
12501 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
12502 return err
12503 }
12504 if _, err := cw.WriteString(string("title")); err != nil {
12505 return err
12506 }
12507
12508 if len(t.Title) > 1000000 {
12509 return xerrors.Errorf("Value in field t.Title was too long")
12510 }
12511
12512 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
12513 return err
12514 }
12515 if _, err := cw.WriteString(string(t.Title)); err != nil {
12516 return err
12517 }
12518
12519 // t.Rounds ([]*tangled.RepoPull_Round) (slice)
12520 if len("rounds") > 1000000 {
12521 return xerrors.Errorf("Value in field \"rounds\" was too long")
12522 }
12523
12524 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("rounds"))); err != nil {
12525 return err
12526 }
12527 if _, err := cw.WriteString(string("rounds")); err != nil {
12528 return err
12529 }
12530
12531 if len(t.Rounds) > 8192 {
12532 return xerrors.Errorf("Slice value in field t.Rounds was too long")
12533 }
12534
12535 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Rounds))); err != nil {
12536 return err
12537 }
12538 for _, v := range t.Rounds {
12539 if err := v.MarshalCBOR(cw); err != nil {
12540 return err
12541 }
12542
12543 }
12544
12545 // t.Source (tangled.RepoPull_Source) (struct)
12546 if t.Source != nil {
12547
12548 if len("source") > 1000000 {
12549 return xerrors.Errorf("Value in field \"source\" was too long")
12550 }
12551
12552 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
12553 return err
12554 }
12555 if _, err := cw.WriteString(string("source")); err != nil {
12556 return err
12557 }
12558
12559 if err := t.Source.MarshalCBOR(cw); err != nil {
12560 return err
12561 }
12562 }
12563
12564 // t.Target (tangled.RepoPull_Target) (struct)
12565 if len("target") > 1000000 {
12566 return xerrors.Errorf("Value in field \"target\" was too long")
12567 }
12568
12569 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("target"))); err != nil {
12570 return err
12571 }
12572 if _, err := cw.WriteString(string("target")); err != nil {
12573 return err
12574 }
12575
12576 if err := t.Target.MarshalCBOR(cw); err != nil {
12577 return err
12578 }
12579
12580 // t.Mentions ([]string) (slice)
12581 if t.Mentions != nil {
12582
12583 if len("mentions") > 1000000 {
12584 return xerrors.Errorf("Value in field \"mentions\" was too long")
12585 }
12586
12587 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
12588 return err
12589 }
12590 if _, err := cw.WriteString(string("mentions")); err != nil {
12591 return err
12592 }
12593
12594 if len(t.Mentions) > 8192 {
12595 return xerrors.Errorf("Slice value in field t.Mentions was too long")
12596 }
12597
12598 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
12599 return err
12600 }
12601 for _, v := range t.Mentions {
12602 if len(v) > 1000000 {
12603 return xerrors.Errorf("Value in field v was too long")
12604 }
12605
12606 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
12607 return err
12608 }
12609 if _, err := cw.WriteString(string(v)); err != nil {
12610 return err
12611 }
12612
12613 }
12614 }
12615
12616 // t.CreatedAt (string) (string)
12617 if len("createdAt") > 1000000 {
12618 return xerrors.Errorf("Value in field \"createdAt\" was too long")
12619 }
12620
12621 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
12622 return err
12623 }
12624 if _, err := cw.WriteString(string("createdAt")); err != nil {
12625 return err
12626 }
12627
12628 if len(t.CreatedAt) > 1000000 {
12629 return xerrors.Errorf("Value in field t.CreatedAt was too long")
12630 }
12631
12632 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
12633 return err
12634 }
12635 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
12636 return err
12637 }
12638
12639 // t.References ([]string) (slice)
12640 if t.References != nil {
12641
12642 if len("references") > 1000000 {
12643 return xerrors.Errorf("Value in field \"references\" was too long")
12644 }
12645
12646 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
12647 return err
12648 }
12649 if _, err := cw.WriteString(string("references")); err != nil {
12650 return err
12651 }
12652
12653 if len(t.References) > 8192 {
12654 return xerrors.Errorf("Slice value in field t.References was too long")
12655 }
12656
12657 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
12658 return err
12659 }
12660 for _, v := range t.References {
12661 if len(v) > 1000000 {
12662 return xerrors.Errorf("Value in field v was too long")
12663 }
12664
12665 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
12666 return err
12667 }
12668 if _, err := cw.WriteString(string(v)); err != nil {
12669 return err
12670 }
12671
12672 }
12673 }
12674
12675 // t.DependentOn (string) (string)
12676 if t.DependentOn != nil {
12677
12678 if len("dependentOn") > 1000000 {
12679 return xerrors.Errorf("Value in field \"dependentOn\" was too long")
12680 }
12681
12682 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("dependentOn"))); err != nil {
12683 return err
12684 }
12685 if _, err := cw.WriteString(string("dependentOn")); err != nil {
12686 return err
12687 }
12688
12689 if t.DependentOn == nil {
12690 if _, err := cw.Write(cbg.CborNull); err != nil {
12691 return err
12692 }
12693 } else {
12694 if len(*t.DependentOn) > 1000000 {
12695 return xerrors.Errorf("Value in field t.DependentOn was too long")
12696 }
12697
12698 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.DependentOn))); err != nil {
12699 return err
12700 }
12701 if _, err := cw.WriteString(string(*t.DependentOn)); err != nil {
12702 return err
12703 }
12704 }
12705 }
12706 return nil
12707}
12708
12709func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) {
12710 *t = RepoPull{}
12711
12712 cr := cbg.NewCborReader(r)
12713
12714 maj, extra, err := cr.ReadHeader()
12715 if err != nil {
12716 return err
12717 }
12718 defer func() {
12719 if err == io.EOF {
12720 err = io.ErrUnexpectedEOF
12721 }
12722 }()
12723
12724 if maj != cbg.MajMap {
12725 return fmt.Errorf("cbor input should be of type map")
12726 }
12727
12728 if extra > cbg.MaxLength {
12729 return fmt.Errorf("RepoPull: map struct too large (%d)", extra)
12730 }
12731
12732 n := extra
12733
12734 nameBuf := make([]byte, 11)
12735 for i := uint64(0); i < n; i++ {
12736 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
12737 if err != nil {
12738 return err
12739 }
12740
12741 if !ok {
12742 // Field doesn't exist on this type, so ignore it
12743 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
12744 return err
12745 }
12746 continue
12747 }
12748
12749 switch string(nameBuf[:nameLen]) {
12750 // t.Body (string) (string)
12751 case "body":
12752
12753 {
12754 b, err := cr.ReadByte()
12755 if err != nil {
12756 return err
12757 }
12758 if b != cbg.CborNull[0] {
12759 if err := cr.UnreadByte(); err != nil {
12760 return err
12761 }
12762
12763 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12764 if err != nil {
12765 return err
12766 }
12767
12768 t.Body = (*string)(&sval)
12769 }
12770 }
12771 // t.LexiconTypeID (string) (string)
12772 case "$type":
12773
12774 {
12775 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12776 if err != nil {
12777 return err
12778 }
12779
12780 t.LexiconTypeID = string(sval)
12781 }
12782 // t.Title (string) (string)
12783 case "title":
12784
12785 {
12786 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12787 if err != nil {
12788 return err
12789 }
12790
12791 t.Title = string(sval)
12792 }
12793 // t.Rounds ([]*tangled.RepoPull_Round) (slice)
12794 case "rounds":
12795
12796 maj, extra, err = cr.ReadHeader()
12797 if err != nil {
12798 return err
12799 }
12800
12801 if extra > 8192 {
12802 return fmt.Errorf("t.Rounds: array too large (%d)", extra)
12803 }
12804
12805 if maj != cbg.MajArray {
12806 return fmt.Errorf("expected cbor array")
12807 }
12808
12809 if extra > 0 {
12810 t.Rounds = make([]*RepoPull_Round, extra)
12811 }
12812
12813 for i := 0; i < int(extra); i++ {
12814 {
12815 var maj byte
12816 var extra uint64
12817 var err error
12818 _ = maj
12819 _ = extra
12820 _ = err
12821
12822 {
12823
12824 b, err := cr.ReadByte()
12825 if err != nil {
12826 return err
12827 }
12828 if b != cbg.CborNull[0] {
12829 if err := cr.UnreadByte(); err != nil {
12830 return err
12831 }
12832 t.Rounds[i] = new(RepoPull_Round)
12833 if err := t.Rounds[i].UnmarshalCBOR(cr); err != nil {
12834 return xerrors.Errorf("unmarshaling t.Rounds[i] pointer: %w", err)
12835 }
12836 }
12837
12838 }
12839
12840 }
12841 }
12842 // t.Source (tangled.RepoPull_Source) (struct)
12843 case "source":
12844
12845 {
12846
12847 b, err := cr.ReadByte()
12848 if err != nil {
12849 return err
12850 }
12851 if b != cbg.CborNull[0] {
12852 if err := cr.UnreadByte(); err != nil {
12853 return err
12854 }
12855 t.Source = new(RepoPull_Source)
12856 if err := t.Source.UnmarshalCBOR(cr); err != nil {
12857 return xerrors.Errorf("unmarshaling t.Source pointer: %w", err)
12858 }
12859 }
12860
12861 }
12862 // t.Target (tangled.RepoPull_Target) (struct)
12863 case "target":
12864
12865 {
12866
12867 b, err := cr.ReadByte()
12868 if err != nil {
12869 return err
12870 }
12871 if b != cbg.CborNull[0] {
12872 if err := cr.UnreadByte(); err != nil {
12873 return err
12874 }
12875 t.Target = new(RepoPull_Target)
12876 if err := t.Target.UnmarshalCBOR(cr); err != nil {
12877 return xerrors.Errorf("unmarshaling t.Target pointer: %w", err)
12878 }
12879 }
12880
12881 }
12882 // t.Mentions ([]string) (slice)
12883 case "mentions":
12884
12885 maj, extra, err = cr.ReadHeader()
12886 if err != nil {
12887 return err
12888 }
12889
12890 if extra > 8192 {
12891 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
12892 }
12893
12894 if maj != cbg.MajArray {
12895 return fmt.Errorf("expected cbor array")
12896 }
12897
12898 if extra > 0 {
12899 t.Mentions = make([]string, extra)
12900 }
12901
12902 for i := 0; i < int(extra); i++ {
12903 {
12904 var maj byte
12905 var extra uint64
12906 var err error
12907 _ = maj
12908 _ = extra
12909 _ = err
12910
12911 {
12912 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12913 if err != nil {
12914 return err
12915 }
12916
12917 t.Mentions[i] = string(sval)
12918 }
12919
12920 }
12921 }
12922 // t.CreatedAt (string) (string)
12923 case "createdAt":
12924
12925 {
12926 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12927 if err != nil {
12928 return err
12929 }
12930
12931 t.CreatedAt = string(sval)
12932 }
12933 // t.References ([]string) (slice)
12934 case "references":
12935
12936 maj, extra, err = cr.ReadHeader()
12937 if err != nil {
12938 return err
12939 }
12940
12941 if extra > 8192 {
12942 return fmt.Errorf("t.References: array too large (%d)", extra)
12943 }
12944
12945 if maj != cbg.MajArray {
12946 return fmt.Errorf("expected cbor array")
12947 }
12948
12949 if extra > 0 {
12950 t.References = make([]string, extra)
12951 }
12952
12953 for i := 0; i < int(extra); i++ {
12954 {
12955 var maj byte
12956 var extra uint64
12957 var err error
12958 _ = maj
12959 _ = extra
12960 _ = err
12961
12962 {
12963 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12964 if err != nil {
12965 return err
12966 }
12967
12968 t.References[i] = string(sval)
12969 }
12970
12971 }
12972 }
12973 // t.DependentOn (string) (string)
12974 case "dependentOn":
12975
12976 {
12977 b, err := cr.ReadByte()
12978 if err != nil {
12979 return err
12980 }
12981 if b != cbg.CborNull[0] {
12982 if err := cr.UnreadByte(); err != nil {
12983 return err
12984 }
12985
12986 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12987 if err != nil {
12988 return err
12989 }
12990
12991 t.DependentOn = (*string)(&sval)
12992 }
12993 }
12994
12995 default:
12996 // Field doesn't exist on this type, so ignore it
12997 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
12998 return err
12999 }
13000 }
13001 }
13002
13003 return nil
13004}
13005func (t *RepoPullComment) MarshalCBOR(w io.Writer) error {
13006 if t == nil {
13007 _, err := w.Write(cbg.CborNull)
13008 return err
13009 }
13010
13011 cw := cbg.NewCborWriter(w)
13012 fieldCount := 6
13013
13014 if t.Mentions == nil {
13015 fieldCount--
13016 }
13017
13018 if t.References == nil {
13019 fieldCount--
13020 }
13021
13022 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
13023 return err
13024 }
13025
13026 // t.Body (string) (string)
13027 if len("body") > 1000000 {
13028 return xerrors.Errorf("Value in field \"body\" was too long")
13029 }
13030
13031 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
13032 return err
13033 }
13034 if _, err := cw.WriteString(string("body")); err != nil {
13035 return err
13036 }
13037
13038 if len(t.Body) > 1000000 {
13039 return xerrors.Errorf("Value in field t.Body was too long")
13040 }
13041
13042 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
13043 return err
13044 }
13045 if _, err := cw.WriteString(string(t.Body)); err != nil {
13046 return err
13047 }
13048
13049 // t.Pull (string) (string)
13050 if len("pull") > 1000000 {
13051 return xerrors.Errorf("Value in field \"pull\" was too long")
13052 }
13053
13054 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
13055 return err
13056 }
13057 if _, err := cw.WriteString(string("pull")); err != nil {
13058 return err
13059 }
13060
13061 if len(t.Pull) > 1000000 {
13062 return xerrors.Errorf("Value in field t.Pull was too long")
13063 }
13064
13065 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
13066 return err
13067 }
13068 if _, err := cw.WriteString(string(t.Pull)); err != nil {
13069 return err
13070 }
13071
13072 // t.LexiconTypeID (string) (string)
13073 if len("$type") > 1000000 {
13074 return xerrors.Errorf("Value in field \"$type\" was too long")
13075 }
13076
13077 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
13078 return err
13079 }
13080 if _, err := cw.WriteString(string("$type")); err != nil {
13081 return err
13082 }
13083
13084 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.comment"))); err != nil {
13085 return err
13086 }
13087 if _, err := cw.WriteString(string("sh.tangled.repo.pull.comment")); err != nil {
13088 return err
13089 }
13090
13091 // t.Mentions ([]string) (slice)
13092 if t.Mentions != nil {
13093
13094 if len("mentions") > 1000000 {
13095 return xerrors.Errorf("Value in field \"mentions\" was too long")
13096 }
13097
13098 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
13099 return err
13100 }
13101 if _, err := cw.WriteString(string("mentions")); err != nil {
13102 return err
13103 }
13104
13105 if len(t.Mentions) > 8192 {
13106 return xerrors.Errorf("Slice value in field t.Mentions was too long")
13107 }
13108
13109 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
13110 return err
13111 }
13112 for _, v := range t.Mentions {
13113 if len(v) > 1000000 {
13114 return xerrors.Errorf("Value in field v was too long")
13115 }
13116
13117 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
13118 return err
13119 }
13120 if _, err := cw.WriteString(string(v)); err != nil {
13121 return err
13122 }
13123
13124 }
13125 }
13126
13127 // t.CreatedAt (string) (string)
13128 if len("createdAt") > 1000000 {
13129 return xerrors.Errorf("Value in field \"createdAt\" was too long")
13130 }
13131
13132 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
13133 return err
13134 }
13135 if _, err := cw.WriteString(string("createdAt")); err != nil {
13136 return err
13137 }
13138
13139 if len(t.CreatedAt) > 1000000 {
13140 return xerrors.Errorf("Value in field t.CreatedAt was too long")
13141 }
13142
13143 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
13144 return err
13145 }
13146 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
13147 return err
13148 }
13149
13150 // t.References ([]string) (slice)
13151 if t.References != nil {
13152
13153 if len("references") > 1000000 {
13154 return xerrors.Errorf("Value in field \"references\" was too long")
13155 }
13156
13157 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
13158 return err
13159 }
13160 if _, err := cw.WriteString(string("references")); err != nil {
13161 return err
13162 }
13163
13164 if len(t.References) > 8192 {
13165 return xerrors.Errorf("Slice value in field t.References was too long")
13166 }
13167
13168 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
13169 return err
13170 }
13171 for _, v := range t.References {
13172 if len(v) > 1000000 {
13173 return xerrors.Errorf("Value in field v was too long")
13174 }
13175
13176 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
13177 return err
13178 }
13179 if _, err := cw.WriteString(string(v)); err != nil {
13180 return err
13181 }
13182
13183 }
13184 }
13185 return nil
13186}
13187
13188func (t *RepoPullComment) UnmarshalCBOR(r io.Reader) (err error) {
13189 *t = RepoPullComment{}
13190
13191 cr := cbg.NewCborReader(r)
13192
13193 maj, extra, err := cr.ReadHeader()
13194 if err != nil {
13195 return err
13196 }
13197 defer func() {
13198 if err == io.EOF {
13199 err = io.ErrUnexpectedEOF
13200 }
13201 }()
13202
13203 if maj != cbg.MajMap {
13204 return fmt.Errorf("cbor input should be of type map")
13205 }
13206
13207 if extra > cbg.MaxLength {
13208 return fmt.Errorf("RepoPullComment: map struct too large (%d)", extra)
13209 }
13210
13211 n := extra
13212
13213 nameBuf := make([]byte, 10)
13214 for i := uint64(0); i < n; i++ {
13215 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
13216 if err != nil {
13217 return err
13218 }
13219
13220 if !ok {
13221 // Field doesn't exist on this type, so ignore it
13222 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
13223 return err
13224 }
13225 continue
13226 }
13227
13228 switch string(nameBuf[:nameLen]) {
13229 // t.Body (string) (string)
13230 case "body":
13231
13232 {
13233 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13234 if err != nil {
13235 return err
13236 }
13237
13238 t.Body = string(sval)
13239 }
13240 // t.Pull (string) (string)
13241 case "pull":
13242
13243 {
13244 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13245 if err != nil {
13246 return err
13247 }
13248
13249 t.Pull = string(sval)
13250 }
13251 // t.LexiconTypeID (string) (string)
13252 case "$type":
13253
13254 {
13255 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13256 if err != nil {
13257 return err
13258 }
13259
13260 t.LexiconTypeID = string(sval)
13261 }
13262 // t.Mentions ([]string) (slice)
13263 case "mentions":
13264
13265 maj, extra, err = cr.ReadHeader()
13266 if err != nil {
13267 return err
13268 }
13269
13270 if extra > 8192 {
13271 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
13272 }
13273
13274 if maj != cbg.MajArray {
13275 return fmt.Errorf("expected cbor array")
13276 }
13277
13278 if extra > 0 {
13279 t.Mentions = make([]string, extra)
13280 }
13281
13282 for i := 0; i < int(extra); i++ {
13283 {
13284 var maj byte
13285 var extra uint64
13286 var err error
13287 _ = maj
13288 _ = extra
13289 _ = err
13290
13291 {
13292 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13293 if err != nil {
13294 return err
13295 }
13296
13297 t.Mentions[i] = string(sval)
13298 }
13299
13300 }
13301 }
13302 // t.CreatedAt (string) (string)
13303 case "createdAt":
13304
13305 {
13306 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13307 if err != nil {
13308 return err
13309 }
13310
13311 t.CreatedAt = string(sval)
13312 }
13313 // t.References ([]string) (slice)
13314 case "references":
13315
13316 maj, extra, err = cr.ReadHeader()
13317 if err != nil {
13318 return err
13319 }
13320
13321 if extra > 8192 {
13322 return fmt.Errorf("t.References: array too large (%d)", extra)
13323 }
13324
13325 if maj != cbg.MajArray {
13326 return fmt.Errorf("expected cbor array")
13327 }
13328
13329 if extra > 0 {
13330 t.References = make([]string, extra)
13331 }
13332
13333 for i := 0; i < int(extra); i++ {
13334 {
13335 var maj byte
13336 var extra uint64
13337 var err error
13338 _ = maj
13339 _ = extra
13340 _ = err
13341
13342 {
13343 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13344 if err != nil {
13345 return err
13346 }
13347
13348 t.References[i] = string(sval)
13349 }
13350
13351 }
13352 }
13353
13354 default:
13355 // Field doesn't exist on this type, so ignore it
13356 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
13357 return err
13358 }
13359 }
13360 }
13361
13362 return nil
13363}
13364func (t *RepoPull_Round) MarshalCBOR(w io.Writer) error {
13365 if t == nil {
13366 _, err := w.Write(cbg.CborNull)
13367 return err
13368 }
13369
13370 cw := cbg.NewCborWriter(w)
13371
13372 if _, err := cw.Write([]byte{162}); err != nil {
13373 return err
13374 }
13375
13376 // t.CreatedAt (string) (string)
13377 if len("createdAt") > 1000000 {
13378 return xerrors.Errorf("Value in field \"createdAt\" was too long")
13379 }
13380
13381 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
13382 return err
13383 }
13384 if _, err := cw.WriteString(string("createdAt")); err != nil {
13385 return err
13386 }
13387
13388 if len(t.CreatedAt) > 1000000 {
13389 return xerrors.Errorf("Value in field t.CreatedAt was too long")
13390 }
13391
13392 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
13393 return err
13394 }
13395 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
13396 return err
13397 }
13398
13399 // t.PatchBlob (util.LexBlob) (struct)
13400 if len("patchBlob") > 1000000 {
13401 return xerrors.Errorf("Value in field \"patchBlob\" was too long")
13402 }
13403
13404 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patchBlob"))); err != nil {
13405 return err
13406 }
13407 if _, err := cw.WriteString(string("patchBlob")); err != nil {
13408 return err
13409 }
13410
13411 if err := t.PatchBlob.MarshalCBOR(cw); err != nil {
13412 return err
13413 }
13414 return nil
13415}
13416
13417func (t *RepoPull_Round) UnmarshalCBOR(r io.Reader) (err error) {
13418 *t = RepoPull_Round{}
13419
13420 cr := cbg.NewCborReader(r)
13421
13422 maj, extra, err := cr.ReadHeader()
13423 if err != nil {
13424 return err
13425 }
13426 defer func() {
13427 if err == io.EOF {
13428 err = io.ErrUnexpectedEOF
13429 }
13430 }()
13431
13432 if maj != cbg.MajMap {
13433 return fmt.Errorf("cbor input should be of type map")
13434 }
13435
13436 if extra > cbg.MaxLength {
13437 return fmt.Errorf("RepoPull_Round: map struct too large (%d)", extra)
13438 }
13439
13440 n := extra
13441
13442 nameBuf := make([]byte, 9)
13443 for i := uint64(0); i < n; i++ {
13444 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
13445 if err != nil {
13446 return err
13447 }
13448
13449 if !ok {
13450 // Field doesn't exist on this type, so ignore it
13451 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
13452 return err
13453 }
13454 continue
13455 }
13456
13457 switch string(nameBuf[:nameLen]) {
13458 // t.CreatedAt (string) (string)
13459 case "createdAt":
13460
13461 {
13462 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13463 if err != nil {
13464 return err
13465 }
13466
13467 t.CreatedAt = string(sval)
13468 }
13469 // t.PatchBlob (util.LexBlob) (struct)
13470 case "patchBlob":
13471
13472 {
13473
13474 b, err := cr.ReadByte()
13475 if err != nil {
13476 return err
13477 }
13478 if b != cbg.CborNull[0] {
13479 if err := cr.UnreadByte(); err != nil {
13480 return err
13481 }
13482 t.PatchBlob = new(util.LexBlob)
13483 if err := t.PatchBlob.UnmarshalCBOR(cr); err != nil {
13484 return xerrors.Errorf("unmarshaling t.PatchBlob pointer: %w", err)
13485 }
13486 }
13487
13488 }
13489
13490 default:
13491 // Field doesn't exist on this type, so ignore it
13492 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
13493 return err
13494 }
13495 }
13496 }
13497
13498 return nil
13499}
13500func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error {
13501 if t == nil {
13502 _, err := w.Write(cbg.CborNull)
13503 return err
13504 }
13505
13506 cw := cbg.NewCborWriter(w)
13507 fieldCount := 2
13508
13509 if t.Repo == nil {
13510 fieldCount--
13511 }
13512
13513 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
13514 return err
13515 }
13516
13517 // t.Repo (string) (string)
13518 if t.Repo != nil {
13519
13520 if len("repo") > 1000000 {
13521 return xerrors.Errorf("Value in field \"repo\" was too long")
13522 }
13523
13524 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
13525 return err
13526 }
13527 if _, err := cw.WriteString(string("repo")); err != nil {
13528 return err
13529 }
13530
13531 if t.Repo == nil {
13532 if _, err := cw.Write(cbg.CborNull); err != nil {
13533 return err
13534 }
13535 } else {
13536 if len(*t.Repo) > 1000000 {
13537 return xerrors.Errorf("Value in field t.Repo was too long")
13538 }
13539
13540 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
13541 return err
13542 }
13543 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
13544 return err
13545 }
13546 }
13547 }
13548
13549 // t.Branch (string) (string)
13550 if len("branch") > 1000000 {
13551 return xerrors.Errorf("Value in field \"branch\" was too long")
13552 }
13553
13554 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
13555 return err
13556 }
13557 if _, err := cw.WriteString(string("branch")); err != nil {
13558 return err
13559 }
13560
13561 if len(t.Branch) > 1000000 {
13562 return xerrors.Errorf("Value in field t.Branch was too long")
13563 }
13564
13565 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
13566 return err
13567 }
13568 if _, err := cw.WriteString(string(t.Branch)); err != nil {
13569 return err
13570 }
13571 return nil
13572}
13573
13574func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) {
13575 *t = RepoPull_Source{}
13576
13577 cr := cbg.NewCborReader(r)
13578
13579 maj, extra, err := cr.ReadHeader()
13580 if err != nil {
13581 return err
13582 }
13583 defer func() {
13584 if err == io.EOF {
13585 err = io.ErrUnexpectedEOF
13586 }
13587 }()
13588
13589 if maj != cbg.MajMap {
13590 return fmt.Errorf("cbor input should be of type map")
13591 }
13592
13593 if extra > cbg.MaxLength {
13594 return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra)
13595 }
13596
13597 n := extra
13598
13599 nameBuf := make([]byte, 6)
13600 for i := uint64(0); i < n; i++ {
13601 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
13602 if err != nil {
13603 return err
13604 }
13605
13606 if !ok {
13607 // Field doesn't exist on this type, so ignore it
13608 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
13609 return err
13610 }
13611 continue
13612 }
13613
13614 switch string(nameBuf[:nameLen]) {
13615 // t.Repo (string) (string)
13616 case "repo":
13617
13618 {
13619 b, err := cr.ReadByte()
13620 if err != nil {
13621 return err
13622 }
13623 if b != cbg.CborNull[0] {
13624 if err := cr.UnreadByte(); err != nil {
13625 return err
13626 }
13627
13628 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13629 if err != nil {
13630 return err
13631 }
13632
13633 t.Repo = (*string)(&sval)
13634 }
13635 }
13636 // t.Branch (string) (string)
13637 case "branch":
13638
13639 {
13640 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13641 if err != nil {
13642 return err
13643 }
13644
13645 t.Branch = string(sval)
13646 }
13647
13648 default:
13649 // Field doesn't exist on this type, so ignore it
13650 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
13651 return err
13652 }
13653 }
13654 }
13655
13656 return nil
13657}
13658func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error {
13659 if t == nil {
13660 _, err := w.Write(cbg.CborNull)
13661 return err
13662 }
13663
13664 cw := cbg.NewCborWriter(w)
13665
13666 if _, err := cw.Write([]byte{164}); err != nil {
13667 return err
13668 }
13669
13670 // t.Pull (string) (string)
13671 if len("pull") > 1000000 {
13672 return xerrors.Errorf("Value in field \"pull\" was too long")
13673 }
13674
13675 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
13676 return err
13677 }
13678 if _, err := cw.WriteString(string("pull")); err != nil {
13679 return err
13680 }
13681
13682 if len(t.Pull) > 1000000 {
13683 return xerrors.Errorf("Value in field t.Pull was too long")
13684 }
13685
13686 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
13687 return err
13688 }
13689 if _, err := cw.WriteString(string(t.Pull)); err != nil {
13690 return err
13691 }
13692
13693 // t.LexiconTypeID (string) (string)
13694 if len("$type") > 1000000 {
13695 return xerrors.Errorf("Value in field \"$type\" was too long")
13696 }
13697
13698 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
13699 return err
13700 }
13701 if _, err := cw.WriteString(string("$type")); err != nil {
13702 return err
13703 }
13704
13705 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil {
13706 return err
13707 }
13708 if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil {
13709 return err
13710 }
13711
13712 // t.Status (string) (string)
13713 if len("status") > 1000000 {
13714 return xerrors.Errorf("Value in field \"status\" was too long")
13715 }
13716
13717 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
13718 return err
13719 }
13720 if _, err := cw.WriteString(string("status")); err != nil {
13721 return err
13722 }
13723
13724 if len(t.Status) > 1000000 {
13725 return xerrors.Errorf("Value in field t.Status was too long")
13726 }
13727
13728 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
13729 return err
13730 }
13731 if _, err := cw.WriteString(string(t.Status)); err != nil {
13732 return err
13733 }
13734
13735 // t.CreatedAt (string) (string)
13736 if len("createdAt") > 1000000 {
13737 return xerrors.Errorf("Value in field \"createdAt\" was too long")
13738 }
13739
13740 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
13741 return err
13742 }
13743 if _, err := cw.WriteString(string("createdAt")); err != nil {
13744 return err
13745 }
13746
13747 if len(t.CreatedAt) > 1000000 {
13748 return xerrors.Errorf("Value in field t.CreatedAt was too long")
13749 }
13750
13751 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
13752 return err
13753 }
13754 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
13755 return err
13756 }
13757 return nil
13758}
13759
13760func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) {
13761 *t = RepoPullStatus{}
13762
13763 cr := cbg.NewCborReader(r)
13764
13765 maj, extra, err := cr.ReadHeader()
13766 if err != nil {
13767 return err
13768 }
13769 defer func() {
13770 if err == io.EOF {
13771 err = io.ErrUnexpectedEOF
13772 }
13773 }()
13774
13775 if maj != cbg.MajMap {
13776 return fmt.Errorf("cbor input should be of type map")
13777 }
13778
13779 if extra > cbg.MaxLength {
13780 return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra)
13781 }
13782
13783 n := extra
13784
13785 nameBuf := make([]byte, 9)
13786 for i := uint64(0); i < n; i++ {
13787 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
13788 if err != nil {
13789 return err
13790 }
13791
13792 if !ok {
13793 // Field doesn't exist on this type, so ignore it
13794 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
13795 return err
13796 }
13797 continue
13798 }
13799
13800 switch string(nameBuf[:nameLen]) {
13801 // t.Pull (string) (string)
13802 case "pull":
13803
13804 {
13805 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13806 if err != nil {
13807 return err
13808 }
13809
13810 t.Pull = string(sval)
13811 }
13812 // t.LexiconTypeID (string) (string)
13813 case "$type":
13814
13815 {
13816 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13817 if err != nil {
13818 return err
13819 }
13820
13821 t.LexiconTypeID = string(sval)
13822 }
13823 // t.Status (string) (string)
13824 case "status":
13825
13826 {
13827 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13828 if err != nil {
13829 return err
13830 }
13831
13832 t.Status = string(sval)
13833 }
13834 // t.CreatedAt (string) (string)
13835 case "createdAt":
13836
13837 {
13838 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13839 if err != nil {
13840 return err
13841 }
13842
13843 t.CreatedAt = string(sval)
13844 }
13845
13846 default:
13847 // Field doesn't exist on this type, so ignore it
13848 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
13849 return err
13850 }
13851 }
13852 }
13853
13854 return nil
13855}
13856func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error {
13857 if t == nil {
13858 _, err := w.Write(cbg.CborNull)
13859 return err
13860 }
13861
13862 cw := cbg.NewCborWriter(w)
13863
13864 if _, err := cw.Write([]byte{162}); err != nil {
13865 return err
13866 }
13867
13868 // t.Repo (string) (string)
13869 if len("repo") > 1000000 {
13870 return xerrors.Errorf("Value in field \"repo\" was too long")
13871 }
13872
13873 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
13874 return err
13875 }
13876 if _, err := cw.WriteString(string("repo")); err != nil {
13877 return err
13878 }
13879
13880 if len(t.Repo) > 1000000 {
13881 return xerrors.Errorf("Value in field t.Repo was too long")
13882 }
13883
13884 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
13885 return err
13886 }
13887 if _, err := cw.WriteString(string(t.Repo)); err != nil {
13888 return err
13889 }
13890
13891 // t.Branch (string) (string)
13892 if len("branch") > 1000000 {
13893 return xerrors.Errorf("Value in field \"branch\" was too long")
13894 }
13895
13896 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
13897 return err
13898 }
13899 if _, err := cw.WriteString(string("branch")); err != nil {
13900 return err
13901 }
13902
13903 if len(t.Branch) > 1000000 {
13904 return xerrors.Errorf("Value in field t.Branch was too long")
13905 }
13906
13907 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
13908 return err
13909 }
13910 if _, err := cw.WriteString(string(t.Branch)); err != nil {
13911 return err
13912 }
13913 return nil
13914}
13915
13916func (t *RepoPull_Target) UnmarshalCBOR(r io.Reader) (err error) {
13917 *t = RepoPull_Target{}
13918
13919 cr := cbg.NewCborReader(r)
13920
13921 maj, extra, err := cr.ReadHeader()
13922 if err != nil {
13923 return err
13924 }
13925 defer func() {
13926 if err == io.EOF {
13927 err = io.ErrUnexpectedEOF
13928 }
13929 }()
13930
13931 if maj != cbg.MajMap {
13932 return fmt.Errorf("cbor input should be of type map")
13933 }
13934
13935 if extra > cbg.MaxLength {
13936 return fmt.Errorf("RepoPull_Target: map struct too large (%d)", extra)
13937 }
13938
13939 n := extra
13940
13941 nameBuf := make([]byte, 6)
13942 for i := uint64(0); i < n; i++ {
13943 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
13944 if err != nil {
13945 return err
13946 }
13947
13948 if !ok {
13949 // Field doesn't exist on this type, so ignore it
13950 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
13951 return err
13952 }
13953 continue
13954 }
13955
13956 switch string(nameBuf[:nameLen]) {
13957 // t.Repo (string) (string)
13958 case "repo":
13959
13960 {
13961 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13962 if err != nil {
13963 return err
13964 }
13965
13966 t.Repo = string(sval)
13967 }
13968 // t.Branch (string) (string)
13969 case "branch":
13970
13971 {
13972 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13973 if err != nil {
13974 return err
13975 }
13976
13977 t.Branch = string(sval)
13978 }
13979
13980 default:
13981 // Field doesn't exist on this type, so ignore it
13982 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
13983 return err
13984 }
13985 }
13986 }
13987
13988 return nil
13989}
13990func (t *Spindle) MarshalCBOR(w io.Writer) error {
13991 if t == nil {
13992 _, err := w.Write(cbg.CborNull)
13993 return err
13994 }
13995
13996 cw := cbg.NewCborWriter(w)
13997
13998 if _, err := cw.Write([]byte{162}); err != nil {
13999 return err
14000 }
14001
14002 // t.LexiconTypeID (string) (string)
14003 if len("$type") > 1000000 {
14004 return xerrors.Errorf("Value in field \"$type\" was too long")
14005 }
14006
14007 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
14008 return err
14009 }
14010 if _, err := cw.WriteString(string("$type")); err != nil {
14011 return err
14012 }
14013
14014 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle"))); err != nil {
14015 return err
14016 }
14017 if _, err := cw.WriteString(string("sh.tangled.spindle")); err != nil {
14018 return err
14019 }
14020
14021 // t.CreatedAt (string) (string)
14022 if len("createdAt") > 1000000 {
14023 return xerrors.Errorf("Value in field \"createdAt\" was too long")
14024 }
14025
14026 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
14027 return err
14028 }
14029 if _, err := cw.WriteString(string("createdAt")); err != nil {
14030 return err
14031 }
14032
14033 if len(t.CreatedAt) > 1000000 {
14034 return xerrors.Errorf("Value in field t.CreatedAt was too long")
14035 }
14036
14037 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
14038 return err
14039 }
14040 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
14041 return err
14042 }
14043 return nil
14044}
14045
14046func (t *Spindle) UnmarshalCBOR(r io.Reader) (err error) {
14047 *t = Spindle{}
14048
14049 cr := cbg.NewCborReader(r)
14050
14051 maj, extra, err := cr.ReadHeader()
14052 if err != nil {
14053 return err
14054 }
14055 defer func() {
14056 if err == io.EOF {
14057 err = io.ErrUnexpectedEOF
14058 }
14059 }()
14060
14061 if maj != cbg.MajMap {
14062 return fmt.Errorf("cbor input should be of type map")
14063 }
14064
14065 if extra > cbg.MaxLength {
14066 return fmt.Errorf("Spindle: map struct too large (%d)", extra)
14067 }
14068
14069 n := extra
14070
14071 nameBuf := make([]byte, 9)
14072 for i := uint64(0); i < n; i++ {
14073 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
14074 if err != nil {
14075 return err
14076 }
14077
14078 if !ok {
14079 // Field doesn't exist on this type, so ignore it
14080 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
14081 return err
14082 }
14083 continue
14084 }
14085
14086 switch string(nameBuf[:nameLen]) {
14087 // t.LexiconTypeID (string) (string)
14088 case "$type":
14089
14090 {
14091 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14092 if err != nil {
14093 return err
14094 }
14095
14096 t.LexiconTypeID = string(sval)
14097 }
14098 // t.CreatedAt (string) (string)
14099 case "createdAt":
14100
14101 {
14102 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14103 if err != nil {
14104 return err
14105 }
14106
14107 t.CreatedAt = string(sval)
14108 }
14109
14110 default:
14111 // Field doesn't exist on this type, so ignore it
14112 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
14113 return err
14114 }
14115 }
14116 }
14117
14118 return nil
14119}
14120func (t *SpindleMember) MarshalCBOR(w io.Writer) error {
14121 if t == nil {
14122 _, err := w.Write(cbg.CborNull)
14123 return err
14124 }
14125
14126 cw := cbg.NewCborWriter(w)
14127
14128 if _, err := cw.Write([]byte{164}); err != nil {
14129 return err
14130 }
14131
14132 // t.LexiconTypeID (string) (string)
14133 if len("$type") > 1000000 {
14134 return xerrors.Errorf("Value in field \"$type\" was too long")
14135 }
14136
14137 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
14138 return err
14139 }
14140 if _, err := cw.WriteString(string("$type")); err != nil {
14141 return err
14142 }
14143
14144 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle.member"))); err != nil {
14145 return err
14146 }
14147 if _, err := cw.WriteString(string("sh.tangled.spindle.member")); err != nil {
14148 return err
14149 }
14150
14151 // t.Subject (string) (string)
14152 if len("subject") > 1000000 {
14153 return xerrors.Errorf("Value in field \"subject\" was too long")
14154 }
14155
14156 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
14157 return err
14158 }
14159 if _, err := cw.WriteString(string("subject")); err != nil {
14160 return err
14161 }
14162
14163 if len(t.Subject) > 1000000 {
14164 return xerrors.Errorf("Value in field t.Subject was too long")
14165 }
14166
14167 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
14168 return err
14169 }
14170 if _, err := cw.WriteString(string(t.Subject)); err != nil {
14171 return err
14172 }
14173
14174 // t.Instance (string) (string)
14175 if len("instance") > 1000000 {
14176 return xerrors.Errorf("Value in field \"instance\" was too long")
14177 }
14178
14179 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("instance"))); err != nil {
14180 return err
14181 }
14182 if _, err := cw.WriteString(string("instance")); err != nil {
14183 return err
14184 }
14185
14186 if len(t.Instance) > 1000000 {
14187 return xerrors.Errorf("Value in field t.Instance was too long")
14188 }
14189
14190 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Instance))); err != nil {
14191 return err
14192 }
14193 if _, err := cw.WriteString(string(t.Instance)); err != nil {
14194 return err
14195 }
14196
14197 // t.CreatedAt (string) (string)
14198 if len("createdAt") > 1000000 {
14199 return xerrors.Errorf("Value in field \"createdAt\" was too long")
14200 }
14201
14202 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
14203 return err
14204 }
14205 if _, err := cw.WriteString(string("createdAt")); err != nil {
14206 return err
14207 }
14208
14209 if len(t.CreatedAt) > 1000000 {
14210 return xerrors.Errorf("Value in field t.CreatedAt was too long")
14211 }
14212
14213 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
14214 return err
14215 }
14216 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
14217 return err
14218 }
14219 return nil
14220}
14221
14222func (t *SpindleMember) UnmarshalCBOR(r io.Reader) (err error) {
14223 *t = SpindleMember{}
14224
14225 cr := cbg.NewCborReader(r)
14226
14227 maj, extra, err := cr.ReadHeader()
14228 if err != nil {
14229 return err
14230 }
14231 defer func() {
14232 if err == io.EOF {
14233 err = io.ErrUnexpectedEOF
14234 }
14235 }()
14236
14237 if maj != cbg.MajMap {
14238 return fmt.Errorf("cbor input should be of type map")
14239 }
14240
14241 if extra > cbg.MaxLength {
14242 return fmt.Errorf("SpindleMember: map struct too large (%d)", extra)
14243 }
14244
14245 n := extra
14246
14247 nameBuf := make([]byte, 9)
14248 for i := uint64(0); i < n; i++ {
14249 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
14250 if err != nil {
14251 return err
14252 }
14253
14254 if !ok {
14255 // Field doesn't exist on this type, so ignore it
14256 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
14257 return err
14258 }
14259 continue
14260 }
14261
14262 switch string(nameBuf[:nameLen]) {
14263 // t.LexiconTypeID (string) (string)
14264 case "$type":
14265
14266 {
14267 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14268 if err != nil {
14269 return err
14270 }
14271
14272 t.LexiconTypeID = string(sval)
14273 }
14274 // t.Subject (string) (string)
14275 case "subject":
14276
14277 {
14278 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14279 if err != nil {
14280 return err
14281 }
14282
14283 t.Subject = string(sval)
14284 }
14285 // t.Instance (string) (string)
14286 case "instance":
14287
14288 {
14289 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14290 if err != nil {
14291 return err
14292 }
14293
14294 t.Instance = string(sval)
14295 }
14296 // t.CreatedAt (string) (string)
14297 case "createdAt":
14298
14299 {
14300 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14301 if err != nil {
14302 return err
14303 }
14304
14305 t.CreatedAt = string(sval)
14306 }
14307
14308 default:
14309 // Field doesn't exist on this type, so ignore it
14310 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
14311 return err
14312 }
14313 }
14314 }
14315
14316 return nil
14317}
14318func (t *String) MarshalCBOR(w io.Writer) error {
14319 if t == nil {
14320 _, err := w.Write(cbg.CborNull)
14321 return err
14322 }
14323
14324 cw := cbg.NewCborWriter(w)
14325
14326 if _, err := cw.Write([]byte{165}); err != nil {
14327 return err
14328 }
14329
14330 // t.LexiconTypeID (string) (string)
14331 if len("$type") > 1000000 {
14332 return xerrors.Errorf("Value in field \"$type\" was too long")
14333 }
14334
14335 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
14336 return err
14337 }
14338 if _, err := cw.WriteString(string("$type")); err != nil {
14339 return err
14340 }
14341
14342 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.string"))); err != nil {
14343 return err
14344 }
14345 if _, err := cw.WriteString(string("sh.tangled.string")); err != nil {
14346 return err
14347 }
14348
14349 // t.Contents (string) (string)
14350 if len("contents") > 1000000 {
14351 return xerrors.Errorf("Value in field \"contents\" was too long")
14352 }
14353
14354 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("contents"))); err != nil {
14355 return err
14356 }
14357 if _, err := cw.WriteString(string("contents")); err != nil {
14358 return err
14359 }
14360
14361 if len(t.Contents) > 1000000 {
14362 return xerrors.Errorf("Value in field t.Contents was too long")
14363 }
14364
14365 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Contents))); err != nil {
14366 return err
14367 }
14368 if _, err := cw.WriteString(string(t.Contents)); err != nil {
14369 return err
14370 }
14371
14372 // t.Filename (string) (string)
14373 if len("filename") > 1000000 {
14374 return xerrors.Errorf("Value in field \"filename\" was too long")
14375 }
14376
14377 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("filename"))); err != nil {
14378 return err
14379 }
14380 if _, err := cw.WriteString(string("filename")); err != nil {
14381 return err
14382 }
14383
14384 if len(t.Filename) > 1000000 {
14385 return xerrors.Errorf("Value in field t.Filename was too long")
14386 }
14387
14388 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Filename))); err != nil {
14389 return err
14390 }
14391 if _, err := cw.WriteString(string(t.Filename)); err != nil {
14392 return err
14393 }
14394
14395 // t.CreatedAt (string) (string)
14396 if len("createdAt") > 1000000 {
14397 return xerrors.Errorf("Value in field \"createdAt\" was too long")
14398 }
14399
14400 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
14401 return err
14402 }
14403 if _, err := cw.WriteString(string("createdAt")); err != nil {
14404 return err
14405 }
14406
14407 if len(t.CreatedAt) > 1000000 {
14408 return xerrors.Errorf("Value in field t.CreatedAt was too long")
14409 }
14410
14411 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
14412 return err
14413 }
14414 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
14415 return err
14416 }
14417
14418 // t.Description (string) (string)
14419 if len("description") > 1000000 {
14420 return xerrors.Errorf("Value in field \"description\" was too long")
14421 }
14422
14423 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
14424 return err
14425 }
14426 if _, err := cw.WriteString(string("description")); err != nil {
14427 return err
14428 }
14429
14430 if len(t.Description) > 1000000 {
14431 return xerrors.Errorf("Value in field t.Description was too long")
14432 }
14433
14434 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil {
14435 return err
14436 }
14437 if _, err := cw.WriteString(string(t.Description)); err != nil {
14438 return err
14439 }
14440 return nil
14441}
14442
14443func (t *String) UnmarshalCBOR(r io.Reader) (err error) {
14444 *t = String{}
14445
14446 cr := cbg.NewCborReader(r)
14447
14448 maj, extra, err := cr.ReadHeader()
14449 if err != nil {
14450 return err
14451 }
14452 defer func() {
14453 if err == io.EOF {
14454 err = io.ErrUnexpectedEOF
14455 }
14456 }()
14457
14458 if maj != cbg.MajMap {
14459 return fmt.Errorf("cbor input should be of type map")
14460 }
14461
14462 if extra > cbg.MaxLength {
14463 return fmt.Errorf("String: map struct too large (%d)", extra)
14464 }
14465
14466 n := extra
14467
14468 nameBuf := make([]byte, 11)
14469 for i := uint64(0); i < n; i++ {
14470 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
14471 if err != nil {
14472 return err
14473 }
14474
14475 if !ok {
14476 // Field doesn't exist on this type, so ignore it
14477 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
14478 return err
14479 }
14480 continue
14481 }
14482
14483 switch string(nameBuf[:nameLen]) {
14484 // t.LexiconTypeID (string) (string)
14485 case "$type":
14486
14487 {
14488 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14489 if err != nil {
14490 return err
14491 }
14492
14493 t.LexiconTypeID = string(sval)
14494 }
14495 // t.Contents (string) (string)
14496 case "contents":
14497
14498 {
14499 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14500 if err != nil {
14501 return err
14502 }
14503
14504 t.Contents = string(sval)
14505 }
14506 // t.Filename (string) (string)
14507 case "filename":
14508
14509 {
14510 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14511 if err != nil {
14512 return err
14513 }
14514
14515 t.Filename = string(sval)
14516 }
14517 // t.CreatedAt (string) (string)
14518 case "createdAt":
14519
14520 {
14521 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14522 if err != nil {
14523 return err
14524 }
14525
14526 t.CreatedAt = string(sval)
14527 }
14528 // t.Description (string) (string)
14529 case "description":
14530
14531 {
14532 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14533 if err != nil {
14534 return err
14535 }
14536
14537 t.Description = string(sval)
14538 }
14539
14540 default:
14541 // Field doesn't exist on this type, so ignore it
14542 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
14543 return err
14544 }
14545 }
14546 }
14547
14548 return nil
14549}