alice.pds.demo.boltless.dev
This repository has no description
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 fieldCount := 5
9753
9754 if t.RunsOn == nil {
9755 fieldCount--
9756 }
9757
9758 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
9759 return err
9760 }
9761
9762 // t.Raw (string) (string)
9763 if len("raw") > 1000000 {
9764 return xerrors.Errorf("Value in field \"raw\" was too long")
9765 }
9766
9767 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("raw"))); err != nil {
9768 return err
9769 }
9770 if _, err := cw.WriteString(string("raw")); err != nil {
9771 return err
9772 }
9773
9774 if len(t.Raw) > 1000000 {
9775 return xerrors.Errorf("Value in field t.Raw was too long")
9776 }
9777
9778 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Raw))); err != nil {
9779 return err
9780 }
9781 if _, err := cw.WriteString(string(t.Raw)); err != nil {
9782 return err
9783 }
9784
9785 // t.Name (string) (string)
9786 if len("name") > 1000000 {
9787 return xerrors.Errorf("Value in field \"name\" was too long")
9788 }
9789
9790 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
9791 return err
9792 }
9793 if _, err := cw.WriteString(string("name")); err != nil {
9794 return err
9795 }
9796
9797 if len(t.Name) > 1000000 {
9798 return xerrors.Errorf("Value in field t.Name was too long")
9799 }
9800
9801 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
9802 return err
9803 }
9804 if _, err := cw.WriteString(string(t.Name)); err != nil {
9805 return err
9806 }
9807
9808 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
9809 if len("clone") > 1000000 {
9810 return xerrors.Errorf("Value in field \"clone\" was too long")
9811 }
9812
9813 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil {
9814 return err
9815 }
9816 if _, err := cw.WriteString(string("clone")); err != nil {
9817 return err
9818 }
9819
9820 if err := t.Clone.MarshalCBOR(cw); err != nil {
9821 return err
9822 }
9823
9824 // t.Engine (string) (string)
9825 if len("engine") > 1000000 {
9826 return xerrors.Errorf("Value in field \"engine\" was too long")
9827 }
9828
9829 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("engine"))); err != nil {
9830 return err
9831 }
9832 if _, err := cw.WriteString(string("engine")); err != nil {
9833 return err
9834 }
9835
9836 if len(t.Engine) > 1000000 {
9837 return xerrors.Errorf("Value in field t.Engine was too long")
9838 }
9839
9840 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Engine))); err != nil {
9841 return err
9842 }
9843 if _, err := cw.WriteString(string(t.Engine)); err != nil {
9844 return err
9845 }
9846
9847 // t.RunsOn ([]string) (slice)
9848 if t.RunsOn != nil {
9849
9850 if len("runsOn") > 1000000 {
9851 return xerrors.Errorf("Value in field \"runsOn\" was too long")
9852 }
9853
9854 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("runsOn"))); err != nil {
9855 return err
9856 }
9857 if _, err := cw.WriteString(string("runsOn")); err != nil {
9858 return err
9859 }
9860
9861 if len(t.RunsOn) > 8192 {
9862 return xerrors.Errorf("Slice value in field t.RunsOn was too long")
9863 }
9864
9865 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.RunsOn))); err != nil {
9866 return err
9867 }
9868 for _, v := range t.RunsOn {
9869 if len(v) > 1000000 {
9870 return xerrors.Errorf("Value in field v was too long")
9871 }
9872
9873 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
9874 return err
9875 }
9876 if _, err := cw.WriteString(string(v)); err != nil {
9877 return err
9878 }
9879
9880 }
9881 }
9882 return nil
9883}
9884
9885func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) {
9886 *t = Pipeline_Workflow{}
9887
9888 cr := cbg.NewCborReader(r)
9889
9890 maj, extra, err := cr.ReadHeader()
9891 if err != nil {
9892 return err
9893 }
9894 defer func() {
9895 if err == io.EOF {
9896 err = io.ErrUnexpectedEOF
9897 }
9898 }()
9899
9900 if maj != cbg.MajMap {
9901 return fmt.Errorf("cbor input should be of type map")
9902 }
9903
9904 if extra > cbg.MaxLength {
9905 return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra)
9906 }
9907
9908 n := extra
9909
9910 nameBuf := make([]byte, 6)
9911 for i := uint64(0); i < n; i++ {
9912 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9913 if err != nil {
9914 return err
9915 }
9916
9917 if !ok {
9918 // Field doesn't exist on this type, so ignore it
9919 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9920 return err
9921 }
9922 continue
9923 }
9924
9925 switch string(nameBuf[:nameLen]) {
9926 // t.Raw (string) (string)
9927 case "raw":
9928
9929 {
9930 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9931 if err != nil {
9932 return err
9933 }
9934
9935 t.Raw = string(sval)
9936 }
9937 // t.Name (string) (string)
9938 case "name":
9939
9940 {
9941 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9942 if err != nil {
9943 return err
9944 }
9945
9946 t.Name = string(sval)
9947 }
9948 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
9949 case "clone":
9950
9951 {
9952
9953 b, err := cr.ReadByte()
9954 if err != nil {
9955 return err
9956 }
9957 if b != cbg.CborNull[0] {
9958 if err := cr.UnreadByte(); err != nil {
9959 return err
9960 }
9961 t.Clone = new(Pipeline_CloneOpts)
9962 if err := t.Clone.UnmarshalCBOR(cr); err != nil {
9963 return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err)
9964 }
9965 }
9966
9967 }
9968 // t.Engine (string) (string)
9969 case "engine":
9970
9971 {
9972 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9973 if err != nil {
9974 return err
9975 }
9976
9977 t.Engine = string(sval)
9978 }
9979 // t.RunsOn ([]string) (slice)
9980 case "runsOn":
9981
9982 maj, extra, err = cr.ReadHeader()
9983 if err != nil {
9984 return err
9985 }
9986
9987 if extra > 8192 {
9988 return fmt.Errorf("t.RunsOn: array too large (%d)", extra)
9989 }
9990
9991 if maj != cbg.MajArray {
9992 return fmt.Errorf("expected cbor array")
9993 }
9994
9995 if extra > 0 {
9996 t.RunsOn = make([]string, extra)
9997 }
9998
9999 for i := 0; i < int(extra); i++ {
10000 {
10001 var maj byte
10002 var extra uint64
10003 var err error
10004 _ = maj
10005 _ = extra
10006 _ = err
10007
10008 {
10009 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10010 if err != nil {
10011 return err
10012 }
10013
10014 t.RunsOn[i] = string(sval)
10015 }
10016
10017 }
10018 }
10019
10020 default:
10021 // Field doesn't exist on this type, so ignore it
10022 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
10023 return err
10024 }
10025 }
10026 }
10027
10028 return nil
10029}
10030func (t *PublicKey) MarshalCBOR(w io.Writer) error {
10031 if t == nil {
10032 _, err := w.Write(cbg.CborNull)
10033 return err
10034 }
10035
10036 cw := cbg.NewCborWriter(w)
10037
10038 if _, err := cw.Write([]byte{164}); err != nil {
10039 return err
10040 }
10041
10042 // t.Key (string) (string)
10043 if len("key") > 1000000 {
10044 return xerrors.Errorf("Value in field \"key\" was too long")
10045 }
10046
10047 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
10048 return err
10049 }
10050 if _, err := cw.WriteString(string("key")); err != nil {
10051 return err
10052 }
10053
10054 if len(t.Key) > 1000000 {
10055 return xerrors.Errorf("Value in field t.Key was too long")
10056 }
10057
10058 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
10059 return err
10060 }
10061 if _, err := cw.WriteString(string(t.Key)); err != nil {
10062 return err
10063 }
10064
10065 // t.Name (string) (string)
10066 if len("name") > 1000000 {
10067 return xerrors.Errorf("Value in field \"name\" was too long")
10068 }
10069
10070 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
10071 return err
10072 }
10073 if _, err := cw.WriteString(string("name")); err != nil {
10074 return err
10075 }
10076
10077 if len(t.Name) > 1000000 {
10078 return xerrors.Errorf("Value in field t.Name was too long")
10079 }
10080
10081 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
10082 return err
10083 }
10084 if _, err := cw.WriteString(string(t.Name)); err != nil {
10085 return err
10086 }
10087
10088 // t.LexiconTypeID (string) (string)
10089 if len("$type") > 1000000 {
10090 return xerrors.Errorf("Value in field \"$type\" was too long")
10091 }
10092
10093 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
10094 return err
10095 }
10096 if _, err := cw.WriteString(string("$type")); err != nil {
10097 return err
10098 }
10099
10100 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil {
10101 return err
10102 }
10103 if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil {
10104 return err
10105 }
10106
10107 // t.CreatedAt (string) (string)
10108 if len("createdAt") > 1000000 {
10109 return xerrors.Errorf("Value in field \"createdAt\" was too long")
10110 }
10111
10112 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
10113 return err
10114 }
10115 if _, err := cw.WriteString(string("createdAt")); err != nil {
10116 return err
10117 }
10118
10119 if len(t.CreatedAt) > 1000000 {
10120 return xerrors.Errorf("Value in field t.CreatedAt was too long")
10121 }
10122
10123 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
10124 return err
10125 }
10126 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
10127 return err
10128 }
10129 return nil
10130}
10131
10132func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) {
10133 *t = PublicKey{}
10134
10135 cr := cbg.NewCborReader(r)
10136
10137 maj, extra, err := cr.ReadHeader()
10138 if err != nil {
10139 return err
10140 }
10141 defer func() {
10142 if err == io.EOF {
10143 err = io.ErrUnexpectedEOF
10144 }
10145 }()
10146
10147 if maj != cbg.MajMap {
10148 return fmt.Errorf("cbor input should be of type map")
10149 }
10150
10151 if extra > cbg.MaxLength {
10152 return fmt.Errorf("PublicKey: map struct too large (%d)", extra)
10153 }
10154
10155 n := extra
10156
10157 nameBuf := make([]byte, 9)
10158 for i := uint64(0); i < n; i++ {
10159 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
10160 if err != nil {
10161 return err
10162 }
10163
10164 if !ok {
10165 // Field doesn't exist on this type, so ignore it
10166 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
10167 return err
10168 }
10169 continue
10170 }
10171
10172 switch string(nameBuf[:nameLen]) {
10173 // t.Key (string) (string)
10174 case "key":
10175
10176 {
10177 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10178 if err != nil {
10179 return err
10180 }
10181
10182 t.Key = string(sval)
10183 }
10184 // t.Name (string) (string)
10185 case "name":
10186
10187 {
10188 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10189 if err != nil {
10190 return err
10191 }
10192
10193 t.Name = string(sval)
10194 }
10195 // t.LexiconTypeID (string) (string)
10196 case "$type":
10197
10198 {
10199 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10200 if err != nil {
10201 return err
10202 }
10203
10204 t.LexiconTypeID = string(sval)
10205 }
10206 // t.CreatedAt (string) (string)
10207 case "createdAt":
10208
10209 {
10210 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10211 if err != nil {
10212 return err
10213 }
10214
10215 t.CreatedAt = string(sval)
10216 }
10217
10218 default:
10219 // Field doesn't exist on this type, so ignore it
10220 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
10221 return err
10222 }
10223 }
10224 }
10225
10226 return nil
10227}
10228func (t *Repo) MarshalCBOR(w io.Writer) error {
10229 if t == nil {
10230 _, err := w.Write(cbg.CborNull)
10231 return err
10232 }
10233
10234 cw := cbg.NewCborWriter(w)
10235 fieldCount := 11
10236
10237 if t.Description == nil {
10238 fieldCount--
10239 }
10240
10241 if t.Labels == nil {
10242 fieldCount--
10243 }
10244
10245 if t.Name == nil {
10246 fieldCount--
10247 }
10248
10249 if t.RepoDid == nil {
10250 fieldCount--
10251 }
10252
10253 if t.Source == nil {
10254 fieldCount--
10255 }
10256
10257 if t.Spindle == nil {
10258 fieldCount--
10259 }
10260
10261 if t.Topics == nil {
10262 fieldCount--
10263 }
10264
10265 if t.Website == nil {
10266 fieldCount--
10267 }
10268
10269 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
10270 return err
10271 }
10272
10273 // t.Knot (string) (string)
10274 if len("knot") > 1000000 {
10275 return xerrors.Errorf("Value in field \"knot\" was too long")
10276 }
10277
10278 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
10279 return err
10280 }
10281 if _, err := cw.WriteString(string("knot")); err != nil {
10282 return err
10283 }
10284
10285 if len(t.Knot) > 1000000 {
10286 return xerrors.Errorf("Value in field t.Knot was too long")
10287 }
10288
10289 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
10290 return err
10291 }
10292 if _, err := cw.WriteString(string(t.Knot)); err != nil {
10293 return err
10294 }
10295
10296 // t.Name (string) (string)
10297 if t.Name != nil {
10298
10299 if len("name") > 1000000 {
10300 return xerrors.Errorf("Value in field \"name\" was too long")
10301 }
10302
10303 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
10304 return err
10305 }
10306 if _, err := cw.WriteString(string("name")); err != nil {
10307 return err
10308 }
10309
10310 if t.Name == nil {
10311 if _, err := cw.Write(cbg.CborNull); err != nil {
10312 return err
10313 }
10314 } else {
10315 if len(*t.Name) > 1000000 {
10316 return xerrors.Errorf("Value in field t.Name was too long")
10317 }
10318
10319 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Name))); err != nil {
10320 return err
10321 }
10322 if _, err := cw.WriteString(string(*t.Name)); err != nil {
10323 return err
10324 }
10325 }
10326 }
10327
10328 // t.LexiconTypeID (string) (string)
10329 if len("$type") > 1000000 {
10330 return xerrors.Errorf("Value in field \"$type\" was too long")
10331 }
10332
10333 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
10334 return err
10335 }
10336 if _, err := cw.WriteString(string("$type")); err != nil {
10337 return err
10338 }
10339
10340 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil {
10341 return err
10342 }
10343 if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil {
10344 return err
10345 }
10346
10347 // t.Labels ([]string) (slice)
10348 if t.Labels != nil {
10349
10350 if len("labels") > 1000000 {
10351 return xerrors.Errorf("Value in field \"labels\" was too long")
10352 }
10353
10354 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("labels"))); err != nil {
10355 return err
10356 }
10357 if _, err := cw.WriteString(string("labels")); err != nil {
10358 return err
10359 }
10360
10361 if len(t.Labels) > 8192 {
10362 return xerrors.Errorf("Slice value in field t.Labels was too long")
10363 }
10364
10365 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Labels))); err != nil {
10366 return err
10367 }
10368 for _, v := range t.Labels {
10369 if len(v) > 1000000 {
10370 return xerrors.Errorf("Value in field v was too long")
10371 }
10372
10373 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
10374 return err
10375 }
10376 if _, err := cw.WriteString(string(v)); err != nil {
10377 return err
10378 }
10379
10380 }
10381 }
10382
10383 // t.Source (string) (string)
10384 if t.Source != nil {
10385
10386 if len("source") > 1000000 {
10387 return xerrors.Errorf("Value in field \"source\" was too long")
10388 }
10389
10390 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
10391 return err
10392 }
10393 if _, err := cw.WriteString(string("source")); err != nil {
10394 return err
10395 }
10396
10397 if t.Source == nil {
10398 if _, err := cw.Write(cbg.CborNull); err != nil {
10399 return err
10400 }
10401 } else {
10402 if len(*t.Source) > 1000000 {
10403 return xerrors.Errorf("Value in field t.Source was too long")
10404 }
10405
10406 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil {
10407 return err
10408 }
10409 if _, err := cw.WriteString(string(*t.Source)); err != nil {
10410 return err
10411 }
10412 }
10413 }
10414
10415 // t.Topics ([]string) (slice)
10416 if t.Topics != nil {
10417
10418 if len("topics") > 1000000 {
10419 return xerrors.Errorf("Value in field \"topics\" was too long")
10420 }
10421
10422 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("topics"))); err != nil {
10423 return err
10424 }
10425 if _, err := cw.WriteString(string("topics")); err != nil {
10426 return err
10427 }
10428
10429 if len(t.Topics) > 8192 {
10430 return xerrors.Errorf("Slice value in field t.Topics was too long")
10431 }
10432
10433 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Topics))); err != nil {
10434 return err
10435 }
10436 for _, v := range t.Topics {
10437 if len(v) > 1000000 {
10438 return xerrors.Errorf("Value in field v was too long")
10439 }
10440
10441 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
10442 return err
10443 }
10444 if _, err := cw.WriteString(string(v)); err != nil {
10445 return err
10446 }
10447
10448 }
10449 }
10450
10451 // t.RepoDid (string) (string)
10452 if t.RepoDid != nil {
10453
10454 if len("repoDid") > 1000000 {
10455 return xerrors.Errorf("Value in field \"repoDid\" was too long")
10456 }
10457
10458 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
10459 return err
10460 }
10461 if _, err := cw.WriteString(string("repoDid")); err != nil {
10462 return err
10463 }
10464
10465 if t.RepoDid == nil {
10466 if _, err := cw.Write(cbg.CborNull); err != nil {
10467 return err
10468 }
10469 } else {
10470 if len(*t.RepoDid) > 1000000 {
10471 return xerrors.Errorf("Value in field t.RepoDid was too long")
10472 }
10473
10474 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil {
10475 return err
10476 }
10477 if _, err := cw.WriteString(string(*t.RepoDid)); err != nil {
10478 return err
10479 }
10480 }
10481 }
10482
10483 // t.Spindle (string) (string)
10484 if t.Spindle != nil {
10485
10486 if len("spindle") > 1000000 {
10487 return xerrors.Errorf("Value in field \"spindle\" was too long")
10488 }
10489
10490 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("spindle"))); err != nil {
10491 return err
10492 }
10493 if _, err := cw.WriteString(string("spindle")); err != nil {
10494 return err
10495 }
10496
10497 if t.Spindle == nil {
10498 if _, err := cw.Write(cbg.CborNull); err != nil {
10499 return err
10500 }
10501 } else {
10502 if len(*t.Spindle) > 1000000 {
10503 return xerrors.Errorf("Value in field t.Spindle was too long")
10504 }
10505
10506 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Spindle))); err != nil {
10507 return err
10508 }
10509 if _, err := cw.WriteString(string(*t.Spindle)); err != nil {
10510 return err
10511 }
10512 }
10513 }
10514
10515 // t.Website (string) (string)
10516 if t.Website != nil {
10517
10518 if len("website") > 1000000 {
10519 return xerrors.Errorf("Value in field \"website\" was too long")
10520 }
10521
10522 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("website"))); err != nil {
10523 return err
10524 }
10525 if _, err := cw.WriteString(string("website")); err != nil {
10526 return err
10527 }
10528
10529 if t.Website == nil {
10530 if _, err := cw.Write(cbg.CborNull); err != nil {
10531 return err
10532 }
10533 } else {
10534 if len(*t.Website) > 1000000 {
10535 return xerrors.Errorf("Value in field t.Website was too long")
10536 }
10537
10538 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Website))); err != nil {
10539 return err
10540 }
10541 if _, err := cw.WriteString(string(*t.Website)); err != nil {
10542 return err
10543 }
10544 }
10545 }
10546
10547 // t.CreatedAt (string) (string)
10548 if len("createdAt") > 1000000 {
10549 return xerrors.Errorf("Value in field \"createdAt\" was too long")
10550 }
10551
10552 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
10553 return err
10554 }
10555 if _, err := cw.WriteString(string("createdAt")); err != nil {
10556 return err
10557 }
10558
10559 if len(t.CreatedAt) > 1000000 {
10560 return xerrors.Errorf("Value in field t.CreatedAt was too long")
10561 }
10562
10563 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
10564 return err
10565 }
10566 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
10567 return err
10568 }
10569
10570 // t.Description (string) (string)
10571 if t.Description != nil {
10572
10573 if len("description") > 1000000 {
10574 return xerrors.Errorf("Value in field \"description\" was too long")
10575 }
10576
10577 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
10578 return err
10579 }
10580 if _, err := cw.WriteString(string("description")); err != nil {
10581 return err
10582 }
10583
10584 if t.Description == nil {
10585 if _, err := cw.Write(cbg.CborNull); err != nil {
10586 return err
10587 }
10588 } else {
10589 if len(*t.Description) > 1000000 {
10590 return xerrors.Errorf("Value in field t.Description was too long")
10591 }
10592
10593 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
10594 return err
10595 }
10596 if _, err := cw.WriteString(string(*t.Description)); err != nil {
10597 return err
10598 }
10599 }
10600 }
10601 return nil
10602}
10603
10604func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) {
10605 *t = Repo{}
10606
10607 cr := cbg.NewCborReader(r)
10608
10609 maj, extra, err := cr.ReadHeader()
10610 if err != nil {
10611 return err
10612 }
10613 defer func() {
10614 if err == io.EOF {
10615 err = io.ErrUnexpectedEOF
10616 }
10617 }()
10618
10619 if maj != cbg.MajMap {
10620 return fmt.Errorf("cbor input should be of type map")
10621 }
10622
10623 if extra > cbg.MaxLength {
10624 return fmt.Errorf("Repo: map struct too large (%d)", extra)
10625 }
10626
10627 n := extra
10628
10629 nameBuf := make([]byte, 11)
10630 for i := uint64(0); i < n; i++ {
10631 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
10632 if err != nil {
10633 return err
10634 }
10635
10636 if !ok {
10637 // Field doesn't exist on this type, so ignore it
10638 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
10639 return err
10640 }
10641 continue
10642 }
10643
10644 switch string(nameBuf[:nameLen]) {
10645 // t.Knot (string) (string)
10646 case "knot":
10647
10648 {
10649 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10650 if err != nil {
10651 return err
10652 }
10653
10654 t.Knot = string(sval)
10655 }
10656 // t.Name (string) (string)
10657 case "name":
10658
10659 {
10660 b, err := cr.ReadByte()
10661 if err != nil {
10662 return err
10663 }
10664 if b != cbg.CborNull[0] {
10665 if err := cr.UnreadByte(); err != nil {
10666 return err
10667 }
10668
10669 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10670 if err != nil {
10671 return err
10672 }
10673
10674 t.Name = (*string)(&sval)
10675 }
10676 }
10677 // t.LexiconTypeID (string) (string)
10678 case "$type":
10679
10680 {
10681 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10682 if err != nil {
10683 return err
10684 }
10685
10686 t.LexiconTypeID = string(sval)
10687 }
10688 // t.Labels ([]string) (slice)
10689 case "labels":
10690
10691 maj, extra, err = cr.ReadHeader()
10692 if err != nil {
10693 return err
10694 }
10695
10696 if extra > 8192 {
10697 return fmt.Errorf("t.Labels: array too large (%d)", extra)
10698 }
10699
10700 if maj != cbg.MajArray {
10701 return fmt.Errorf("expected cbor array")
10702 }
10703
10704 if extra > 0 {
10705 t.Labels = make([]string, extra)
10706 }
10707
10708 for i := 0; i < int(extra); i++ {
10709 {
10710 var maj byte
10711 var extra uint64
10712 var err error
10713 _ = maj
10714 _ = extra
10715 _ = err
10716
10717 {
10718 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10719 if err != nil {
10720 return err
10721 }
10722
10723 t.Labels[i] = string(sval)
10724 }
10725
10726 }
10727 }
10728 // t.Source (string) (string)
10729 case "source":
10730
10731 {
10732 b, err := cr.ReadByte()
10733 if err != nil {
10734 return err
10735 }
10736 if b != cbg.CborNull[0] {
10737 if err := cr.UnreadByte(); err != nil {
10738 return err
10739 }
10740
10741 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10742 if err != nil {
10743 return err
10744 }
10745
10746 t.Source = (*string)(&sval)
10747 }
10748 }
10749 // t.Topics ([]string) (slice)
10750 case "topics":
10751
10752 maj, extra, err = cr.ReadHeader()
10753 if err != nil {
10754 return err
10755 }
10756
10757 if extra > 8192 {
10758 return fmt.Errorf("t.Topics: array too large (%d)", extra)
10759 }
10760
10761 if maj != cbg.MajArray {
10762 return fmt.Errorf("expected cbor array")
10763 }
10764
10765 if extra > 0 {
10766 t.Topics = make([]string, extra)
10767 }
10768
10769 for i := 0; i < int(extra); i++ {
10770 {
10771 var maj byte
10772 var extra uint64
10773 var err error
10774 _ = maj
10775 _ = extra
10776 _ = err
10777
10778 {
10779 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10780 if err != nil {
10781 return err
10782 }
10783
10784 t.Topics[i] = string(sval)
10785 }
10786
10787 }
10788 }
10789 // t.RepoDid (string) (string)
10790 case "repoDid":
10791
10792 {
10793 b, err := cr.ReadByte()
10794 if err != nil {
10795 return err
10796 }
10797 if b != cbg.CborNull[0] {
10798 if err := cr.UnreadByte(); err != nil {
10799 return err
10800 }
10801
10802 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10803 if err != nil {
10804 return err
10805 }
10806
10807 t.RepoDid = (*string)(&sval)
10808 }
10809 }
10810 // t.Spindle (string) (string)
10811 case "spindle":
10812
10813 {
10814 b, err := cr.ReadByte()
10815 if err != nil {
10816 return err
10817 }
10818 if b != cbg.CborNull[0] {
10819 if err := cr.UnreadByte(); err != nil {
10820 return err
10821 }
10822
10823 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10824 if err != nil {
10825 return err
10826 }
10827
10828 t.Spindle = (*string)(&sval)
10829 }
10830 }
10831 // t.Website (string) (string)
10832 case "website":
10833
10834 {
10835 b, err := cr.ReadByte()
10836 if err != nil {
10837 return err
10838 }
10839 if b != cbg.CborNull[0] {
10840 if err := cr.UnreadByte(); err != nil {
10841 return err
10842 }
10843
10844 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10845 if err != nil {
10846 return err
10847 }
10848
10849 t.Website = (*string)(&sval)
10850 }
10851 }
10852 // t.CreatedAt (string) (string)
10853 case "createdAt":
10854
10855 {
10856 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10857 if err != nil {
10858 return err
10859 }
10860
10861 t.CreatedAt = string(sval)
10862 }
10863 // t.Description (string) (string)
10864 case "description":
10865
10866 {
10867 b, err := cr.ReadByte()
10868 if err != nil {
10869 return err
10870 }
10871 if b != cbg.CborNull[0] {
10872 if err := cr.UnreadByte(); err != nil {
10873 return err
10874 }
10875
10876 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10877 if err != nil {
10878 return err
10879 }
10880
10881 t.Description = (*string)(&sval)
10882 }
10883 }
10884
10885 default:
10886 // Field doesn't exist on this type, so ignore it
10887 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
10888 return err
10889 }
10890 }
10891 }
10892
10893 return nil
10894}
10895func (t *RepoArtifact) MarshalCBOR(w io.Writer) error {
10896 if t == nil {
10897 _, err := w.Write(cbg.CborNull)
10898 return err
10899 }
10900
10901 cw := cbg.NewCborWriter(w)
10902 fieldCount := 7
10903
10904 if t.Repo == nil {
10905 fieldCount--
10906 }
10907
10908 if t.RepoDid == nil {
10909 fieldCount--
10910 }
10911
10912 if t.Tag == nil {
10913 fieldCount--
10914 }
10915
10916 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
10917 return err
10918 }
10919
10920 // t.Tag (util.LexBytes) (slice)
10921 if t.Tag != nil {
10922
10923 if len("tag") > 1000000 {
10924 return xerrors.Errorf("Value in field \"tag\" was too long")
10925 }
10926
10927 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tag"))); err != nil {
10928 return err
10929 }
10930 if _, err := cw.WriteString(string("tag")); err != nil {
10931 return err
10932 }
10933
10934 if len(t.Tag) > 2097152 {
10935 return xerrors.Errorf("Byte array in field t.Tag was too long")
10936 }
10937
10938 if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Tag))); err != nil {
10939 return err
10940 }
10941
10942 if _, err := cw.Write(t.Tag); err != nil {
10943 return err
10944 }
10945
10946 }
10947
10948 // t.Name (string) (string)
10949 if len("name") > 1000000 {
10950 return xerrors.Errorf("Value in field \"name\" was too long")
10951 }
10952
10953 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
10954 return err
10955 }
10956 if _, err := cw.WriteString(string("name")); err != nil {
10957 return err
10958 }
10959
10960 if len(t.Name) > 1000000 {
10961 return xerrors.Errorf("Value in field t.Name was too long")
10962 }
10963
10964 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
10965 return err
10966 }
10967 if _, err := cw.WriteString(string(t.Name)); err != nil {
10968 return err
10969 }
10970
10971 // t.Repo (string) (string)
10972 if t.Repo != nil {
10973
10974 if len("repo") > 1000000 {
10975 return xerrors.Errorf("Value in field \"repo\" was too long")
10976 }
10977
10978 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
10979 return err
10980 }
10981 if _, err := cw.WriteString(string("repo")); err != nil {
10982 return err
10983 }
10984
10985 if t.Repo == nil {
10986 if _, err := cw.Write(cbg.CborNull); err != nil {
10987 return err
10988 }
10989 } else {
10990 if len(*t.Repo) > 1000000 {
10991 return xerrors.Errorf("Value in field t.Repo was too long")
10992 }
10993
10994 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
10995 return err
10996 }
10997 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
10998 return err
10999 }
11000 }
11001 }
11002
11003 // t.LexiconTypeID (string) (string)
11004 if len("$type") > 1000000 {
11005 return xerrors.Errorf("Value in field \"$type\" was too long")
11006 }
11007
11008 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
11009 return err
11010 }
11011 if _, err := cw.WriteString(string("$type")); err != nil {
11012 return err
11013 }
11014
11015 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.artifact"))); err != nil {
11016 return err
11017 }
11018 if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil {
11019 return err
11020 }
11021
11022 // t.RepoDid (string) (string)
11023 if t.RepoDid != nil {
11024
11025 if len("repoDid") > 1000000 {
11026 return xerrors.Errorf("Value in field \"repoDid\" was too long")
11027 }
11028
11029 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
11030 return err
11031 }
11032 if _, err := cw.WriteString(string("repoDid")); err != nil {
11033 return err
11034 }
11035
11036 if t.RepoDid == nil {
11037 if _, err := cw.Write(cbg.CborNull); err != nil {
11038 return err
11039 }
11040 } else {
11041 if len(*t.RepoDid) > 1000000 {
11042 return xerrors.Errorf("Value in field t.RepoDid was too long")
11043 }
11044
11045 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil {
11046 return err
11047 }
11048 if _, err := cw.WriteString(string(*t.RepoDid)); err != nil {
11049 return err
11050 }
11051 }
11052 }
11053
11054 // t.Artifact (util.LexBlob) (struct)
11055 if len("artifact") > 1000000 {
11056 return xerrors.Errorf("Value in field \"artifact\" was too long")
11057 }
11058
11059 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("artifact"))); err != nil {
11060 return err
11061 }
11062 if _, err := cw.WriteString(string("artifact")); err != nil {
11063 return err
11064 }
11065
11066 if err := t.Artifact.MarshalCBOR(cw); err != nil {
11067 return err
11068 }
11069
11070 // t.CreatedAt (string) (string)
11071 if len("createdAt") > 1000000 {
11072 return xerrors.Errorf("Value in field \"createdAt\" was too long")
11073 }
11074
11075 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
11076 return err
11077 }
11078 if _, err := cw.WriteString(string("createdAt")); err != nil {
11079 return err
11080 }
11081
11082 if len(t.CreatedAt) > 1000000 {
11083 return xerrors.Errorf("Value in field t.CreatedAt was too long")
11084 }
11085
11086 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
11087 return err
11088 }
11089 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
11090 return err
11091 }
11092 return nil
11093}
11094
11095func (t *RepoArtifact) UnmarshalCBOR(r io.Reader) (err error) {
11096 *t = RepoArtifact{}
11097
11098 cr := cbg.NewCborReader(r)
11099
11100 maj, extra, err := cr.ReadHeader()
11101 if err != nil {
11102 return err
11103 }
11104 defer func() {
11105 if err == io.EOF {
11106 err = io.ErrUnexpectedEOF
11107 }
11108 }()
11109
11110 if maj != cbg.MajMap {
11111 return fmt.Errorf("cbor input should be of type map")
11112 }
11113
11114 if extra > cbg.MaxLength {
11115 return fmt.Errorf("RepoArtifact: map struct too large (%d)", extra)
11116 }
11117
11118 n := extra
11119
11120 nameBuf := make([]byte, 9)
11121 for i := uint64(0); i < n; i++ {
11122 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
11123 if err != nil {
11124 return err
11125 }
11126
11127 if !ok {
11128 // Field doesn't exist on this type, so ignore it
11129 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
11130 return err
11131 }
11132 continue
11133 }
11134
11135 switch string(nameBuf[:nameLen]) {
11136 // t.Tag (util.LexBytes) (slice)
11137 case "tag":
11138
11139 maj, extra, err = cr.ReadHeader()
11140 if err != nil {
11141 return err
11142 }
11143
11144 if extra > 2097152 {
11145 return fmt.Errorf("t.Tag: byte array too large (%d)", extra)
11146 }
11147 if maj != cbg.MajByteString {
11148 return fmt.Errorf("expected byte array")
11149 }
11150
11151 if extra > 0 {
11152 t.Tag = make([]uint8, extra)
11153 }
11154
11155 if _, err := io.ReadFull(cr, t.Tag); err != nil {
11156 return err
11157 }
11158
11159 // t.Name (string) (string)
11160 case "name":
11161
11162 {
11163 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11164 if err != nil {
11165 return err
11166 }
11167
11168 t.Name = string(sval)
11169 }
11170 // t.Repo (string) (string)
11171 case "repo":
11172
11173 {
11174 b, err := cr.ReadByte()
11175 if err != nil {
11176 return err
11177 }
11178 if b != cbg.CborNull[0] {
11179 if err := cr.UnreadByte(); err != nil {
11180 return err
11181 }
11182
11183 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11184 if err != nil {
11185 return err
11186 }
11187
11188 t.Repo = (*string)(&sval)
11189 }
11190 }
11191 // t.LexiconTypeID (string) (string)
11192 case "$type":
11193
11194 {
11195 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11196 if err != nil {
11197 return err
11198 }
11199
11200 t.LexiconTypeID = string(sval)
11201 }
11202 // t.RepoDid (string) (string)
11203 case "repoDid":
11204
11205 {
11206 b, err := cr.ReadByte()
11207 if err != nil {
11208 return err
11209 }
11210 if b != cbg.CborNull[0] {
11211 if err := cr.UnreadByte(); err != nil {
11212 return err
11213 }
11214
11215 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11216 if err != nil {
11217 return err
11218 }
11219
11220 t.RepoDid = (*string)(&sval)
11221 }
11222 }
11223 // t.Artifact (util.LexBlob) (struct)
11224 case "artifact":
11225
11226 {
11227
11228 b, err := cr.ReadByte()
11229 if err != nil {
11230 return err
11231 }
11232 if b != cbg.CborNull[0] {
11233 if err := cr.UnreadByte(); err != nil {
11234 return err
11235 }
11236 t.Artifact = new(util.LexBlob)
11237 if err := t.Artifact.UnmarshalCBOR(cr); err != nil {
11238 return xerrors.Errorf("unmarshaling t.Artifact pointer: %w", err)
11239 }
11240 }
11241
11242 }
11243 // t.CreatedAt (string) (string)
11244 case "createdAt":
11245
11246 {
11247 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11248 if err != nil {
11249 return err
11250 }
11251
11252 t.CreatedAt = string(sval)
11253 }
11254
11255 default:
11256 // Field doesn't exist on this type, so ignore it
11257 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
11258 return err
11259 }
11260 }
11261 }
11262
11263 return nil
11264}
11265func (t *RepoCollaborator) MarshalCBOR(w io.Writer) error {
11266 if t == nil {
11267 _, err := w.Write(cbg.CborNull)
11268 return err
11269 }
11270
11271 cw := cbg.NewCborWriter(w)
11272
11273 if _, err := cw.Write([]byte{164}); err != nil {
11274 return err
11275 }
11276
11277 // t.Repo (string) (string)
11278 if len("repo") > 1000000 {
11279 return xerrors.Errorf("Value in field \"repo\" was too long")
11280 }
11281
11282 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
11283 return err
11284 }
11285 if _, err := cw.WriteString(string("repo")); err != nil {
11286 return err
11287 }
11288
11289 if len(t.Repo) > 1000000 {
11290 return xerrors.Errorf("Value in field t.Repo was too long")
11291 }
11292
11293 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
11294 return err
11295 }
11296 if _, err := cw.WriteString(string(t.Repo)); err != nil {
11297 return err
11298 }
11299
11300 // t.LexiconTypeID (string) (string)
11301 if len("$type") > 1000000 {
11302 return xerrors.Errorf("Value in field \"$type\" was too long")
11303 }
11304
11305 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
11306 return err
11307 }
11308 if _, err := cw.WriteString(string("$type")); err != nil {
11309 return err
11310 }
11311
11312 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.collaborator"))); err != nil {
11313 return err
11314 }
11315 if _, err := cw.WriteString(string("sh.tangled.repo.collaborator")); err != nil {
11316 return err
11317 }
11318
11319 // t.Subject (string) (string)
11320 if len("subject") > 1000000 {
11321 return xerrors.Errorf("Value in field \"subject\" was too long")
11322 }
11323
11324 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
11325 return err
11326 }
11327 if _, err := cw.WriteString(string("subject")); err != nil {
11328 return err
11329 }
11330
11331 if len(t.Subject) > 1000000 {
11332 return xerrors.Errorf("Value in field t.Subject was too long")
11333 }
11334
11335 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
11336 return err
11337 }
11338 if _, err := cw.WriteString(string(t.Subject)); err != nil {
11339 return err
11340 }
11341
11342 // t.CreatedAt (string) (string)
11343 if len("createdAt") > 1000000 {
11344 return xerrors.Errorf("Value in field \"createdAt\" was too long")
11345 }
11346
11347 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
11348 return err
11349 }
11350 if _, err := cw.WriteString(string("createdAt")); err != nil {
11351 return err
11352 }
11353
11354 if len(t.CreatedAt) > 1000000 {
11355 return xerrors.Errorf("Value in field t.CreatedAt was too long")
11356 }
11357
11358 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
11359 return err
11360 }
11361 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
11362 return err
11363 }
11364 return nil
11365}
11366
11367func (t *RepoCollaborator) UnmarshalCBOR(r io.Reader) (err error) {
11368 *t = RepoCollaborator{}
11369
11370 cr := cbg.NewCborReader(r)
11371
11372 maj, extra, err := cr.ReadHeader()
11373 if err != nil {
11374 return err
11375 }
11376 defer func() {
11377 if err == io.EOF {
11378 err = io.ErrUnexpectedEOF
11379 }
11380 }()
11381
11382 if maj != cbg.MajMap {
11383 return fmt.Errorf("cbor input should be of type map")
11384 }
11385
11386 if extra > cbg.MaxLength {
11387 return fmt.Errorf("RepoCollaborator: map struct too large (%d)", extra)
11388 }
11389
11390 n := extra
11391
11392 nameBuf := make([]byte, 9)
11393 for i := uint64(0); i < n; i++ {
11394 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
11395 if err != nil {
11396 return err
11397 }
11398
11399 if !ok {
11400 // Field doesn't exist on this type, so ignore it
11401 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
11402 return err
11403 }
11404 continue
11405 }
11406
11407 switch string(nameBuf[:nameLen]) {
11408 // t.Repo (string) (string)
11409 case "repo":
11410
11411 {
11412 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11413 if err != nil {
11414 return err
11415 }
11416
11417 t.Repo = string(sval)
11418 }
11419 // t.LexiconTypeID (string) (string)
11420 case "$type":
11421
11422 {
11423 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11424 if err != nil {
11425 return err
11426 }
11427
11428 t.LexiconTypeID = string(sval)
11429 }
11430 // t.Subject (string) (string)
11431 case "subject":
11432
11433 {
11434 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11435 if err != nil {
11436 return err
11437 }
11438
11439 t.Subject = string(sval)
11440 }
11441 // t.CreatedAt (string) (string)
11442 case "createdAt":
11443
11444 {
11445 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11446 if err != nil {
11447 return err
11448 }
11449
11450 t.CreatedAt = string(sval)
11451 }
11452
11453 default:
11454 // Field doesn't exist on this type, so ignore it
11455 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
11456 return err
11457 }
11458 }
11459 }
11460
11461 return nil
11462}
11463func (t *RepoIssue) MarshalCBOR(w io.Writer) error {
11464 if t == nil {
11465 _, err := w.Write(cbg.CborNull)
11466 return err
11467 }
11468
11469 cw := cbg.NewCborWriter(w)
11470 fieldCount := 7
11471
11472 if t.Body == nil {
11473 fieldCount--
11474 }
11475
11476 if t.Mentions == nil {
11477 fieldCount--
11478 }
11479
11480 if t.References == nil {
11481 fieldCount--
11482 }
11483
11484 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
11485 return err
11486 }
11487
11488 // t.Body (string) (string)
11489 if t.Body != nil {
11490
11491 if len("body") > 1000000 {
11492 return xerrors.Errorf("Value in field \"body\" was too long")
11493 }
11494
11495 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
11496 return err
11497 }
11498 if _, err := cw.WriteString(string("body")); err != nil {
11499 return err
11500 }
11501
11502 if t.Body == nil {
11503 if _, err := cw.Write(cbg.CborNull); err != nil {
11504 return err
11505 }
11506 } else {
11507 if len(*t.Body) > 1000000 {
11508 return xerrors.Errorf("Value in field t.Body was too long")
11509 }
11510
11511 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
11512 return err
11513 }
11514 if _, err := cw.WriteString(string(*t.Body)); err != nil {
11515 return err
11516 }
11517 }
11518 }
11519
11520 // t.Repo (string) (string)
11521 if len("repo") > 1000000 {
11522 return xerrors.Errorf("Value in field \"repo\" was too long")
11523 }
11524
11525 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
11526 return err
11527 }
11528 if _, err := cw.WriteString(string("repo")); err != nil {
11529 return err
11530 }
11531
11532 if len(t.Repo) > 1000000 {
11533 return xerrors.Errorf("Value in field t.Repo was too long")
11534 }
11535
11536 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
11537 return err
11538 }
11539 if _, err := cw.WriteString(string(t.Repo)); err != nil {
11540 return err
11541 }
11542
11543 // t.LexiconTypeID (string) (string)
11544 if len("$type") > 1000000 {
11545 return xerrors.Errorf("Value in field \"$type\" was too long")
11546 }
11547
11548 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
11549 return err
11550 }
11551 if _, err := cw.WriteString(string("$type")); err != nil {
11552 return err
11553 }
11554
11555 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil {
11556 return err
11557 }
11558 if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil {
11559 return err
11560 }
11561
11562 // t.Title (string) (string)
11563 if len("title") > 1000000 {
11564 return xerrors.Errorf("Value in field \"title\" was too long")
11565 }
11566
11567 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
11568 return err
11569 }
11570 if _, err := cw.WriteString(string("title")); err != nil {
11571 return err
11572 }
11573
11574 if len(t.Title) > 1000000 {
11575 return xerrors.Errorf("Value in field t.Title was too long")
11576 }
11577
11578 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
11579 return err
11580 }
11581 if _, err := cw.WriteString(string(t.Title)); err != nil {
11582 return err
11583 }
11584
11585 // t.Mentions ([]string) (slice)
11586 if t.Mentions != nil {
11587
11588 if len("mentions") > 1000000 {
11589 return xerrors.Errorf("Value in field \"mentions\" was too long")
11590 }
11591
11592 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
11593 return err
11594 }
11595 if _, err := cw.WriteString(string("mentions")); err != nil {
11596 return err
11597 }
11598
11599 if len(t.Mentions) > 8192 {
11600 return xerrors.Errorf("Slice value in field t.Mentions was too long")
11601 }
11602
11603 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
11604 return err
11605 }
11606 for _, v := range t.Mentions {
11607 if len(v) > 1000000 {
11608 return xerrors.Errorf("Value in field v was too long")
11609 }
11610
11611 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
11612 return err
11613 }
11614 if _, err := cw.WriteString(string(v)); err != nil {
11615 return err
11616 }
11617
11618 }
11619 }
11620
11621 // t.CreatedAt (string) (string)
11622 if len("createdAt") > 1000000 {
11623 return xerrors.Errorf("Value in field \"createdAt\" was too long")
11624 }
11625
11626 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
11627 return err
11628 }
11629 if _, err := cw.WriteString(string("createdAt")); err != nil {
11630 return err
11631 }
11632
11633 if len(t.CreatedAt) > 1000000 {
11634 return xerrors.Errorf("Value in field t.CreatedAt was too long")
11635 }
11636
11637 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
11638 return err
11639 }
11640 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
11641 return err
11642 }
11643
11644 // t.References ([]string) (slice)
11645 if t.References != nil {
11646
11647 if len("references") > 1000000 {
11648 return xerrors.Errorf("Value in field \"references\" was too long")
11649 }
11650
11651 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
11652 return err
11653 }
11654 if _, err := cw.WriteString(string("references")); err != nil {
11655 return err
11656 }
11657
11658 if len(t.References) > 8192 {
11659 return xerrors.Errorf("Slice value in field t.References was too long")
11660 }
11661
11662 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
11663 return err
11664 }
11665 for _, v := range t.References {
11666 if len(v) > 1000000 {
11667 return xerrors.Errorf("Value in field v was too long")
11668 }
11669
11670 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
11671 return err
11672 }
11673 if _, err := cw.WriteString(string(v)); err != nil {
11674 return err
11675 }
11676
11677 }
11678 }
11679 return nil
11680}
11681
11682func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) {
11683 *t = RepoIssue{}
11684
11685 cr := cbg.NewCborReader(r)
11686
11687 maj, extra, err := cr.ReadHeader()
11688 if err != nil {
11689 return err
11690 }
11691 defer func() {
11692 if err == io.EOF {
11693 err = io.ErrUnexpectedEOF
11694 }
11695 }()
11696
11697 if maj != cbg.MajMap {
11698 return fmt.Errorf("cbor input should be of type map")
11699 }
11700
11701 if extra > cbg.MaxLength {
11702 return fmt.Errorf("RepoIssue: map struct too large (%d)", extra)
11703 }
11704
11705 n := extra
11706
11707 nameBuf := make([]byte, 10)
11708 for i := uint64(0); i < n; i++ {
11709 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
11710 if err != nil {
11711 return err
11712 }
11713
11714 if !ok {
11715 // Field doesn't exist on this type, so ignore it
11716 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
11717 return err
11718 }
11719 continue
11720 }
11721
11722 switch string(nameBuf[:nameLen]) {
11723 // t.Body (string) (string)
11724 case "body":
11725
11726 {
11727 b, err := cr.ReadByte()
11728 if err != nil {
11729 return err
11730 }
11731 if b != cbg.CborNull[0] {
11732 if err := cr.UnreadByte(); err != nil {
11733 return err
11734 }
11735
11736 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11737 if err != nil {
11738 return err
11739 }
11740
11741 t.Body = (*string)(&sval)
11742 }
11743 }
11744 // t.Repo (string) (string)
11745 case "repo":
11746
11747 {
11748 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11749 if err != nil {
11750 return err
11751 }
11752
11753 t.Repo = string(sval)
11754 }
11755 // t.LexiconTypeID (string) (string)
11756 case "$type":
11757
11758 {
11759 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11760 if err != nil {
11761 return err
11762 }
11763
11764 t.LexiconTypeID = string(sval)
11765 }
11766 // t.Title (string) (string)
11767 case "title":
11768
11769 {
11770 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11771 if err != nil {
11772 return err
11773 }
11774
11775 t.Title = string(sval)
11776 }
11777 // t.Mentions ([]string) (slice)
11778 case "mentions":
11779
11780 maj, extra, err = cr.ReadHeader()
11781 if err != nil {
11782 return err
11783 }
11784
11785 if extra > 8192 {
11786 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
11787 }
11788
11789 if maj != cbg.MajArray {
11790 return fmt.Errorf("expected cbor array")
11791 }
11792
11793 if extra > 0 {
11794 t.Mentions = make([]string, extra)
11795 }
11796
11797 for i := 0; i < int(extra); i++ {
11798 {
11799 var maj byte
11800 var extra uint64
11801 var err error
11802 _ = maj
11803 _ = extra
11804 _ = err
11805
11806 {
11807 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11808 if err != nil {
11809 return err
11810 }
11811
11812 t.Mentions[i] = string(sval)
11813 }
11814
11815 }
11816 }
11817 // t.CreatedAt (string) (string)
11818 case "createdAt":
11819
11820 {
11821 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11822 if err != nil {
11823 return err
11824 }
11825
11826 t.CreatedAt = string(sval)
11827 }
11828 // t.References ([]string) (slice)
11829 case "references":
11830
11831 maj, extra, err = cr.ReadHeader()
11832 if err != nil {
11833 return err
11834 }
11835
11836 if extra > 8192 {
11837 return fmt.Errorf("t.References: array too large (%d)", extra)
11838 }
11839
11840 if maj != cbg.MajArray {
11841 return fmt.Errorf("expected cbor array")
11842 }
11843
11844 if extra > 0 {
11845 t.References = make([]string, extra)
11846 }
11847
11848 for i := 0; i < int(extra); i++ {
11849 {
11850 var maj byte
11851 var extra uint64
11852 var err error
11853 _ = maj
11854 _ = extra
11855 _ = err
11856
11857 {
11858 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11859 if err != nil {
11860 return err
11861 }
11862
11863 t.References[i] = string(sval)
11864 }
11865
11866 }
11867 }
11868
11869 default:
11870 // Field doesn't exist on this type, so ignore it
11871 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
11872 return err
11873 }
11874 }
11875 }
11876
11877 return nil
11878}
11879func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error {
11880 if t == nil {
11881 _, err := w.Write(cbg.CborNull)
11882 return err
11883 }
11884
11885 cw := cbg.NewCborWriter(w)
11886 fieldCount := 7
11887
11888 if t.Mentions == nil {
11889 fieldCount--
11890 }
11891
11892 if t.References == nil {
11893 fieldCount--
11894 }
11895
11896 if t.ReplyTo == nil {
11897 fieldCount--
11898 }
11899
11900 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
11901 return err
11902 }
11903
11904 // t.Body (string) (string)
11905 if len("body") > 1000000 {
11906 return xerrors.Errorf("Value in field \"body\" was too long")
11907 }
11908
11909 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
11910 return err
11911 }
11912 if _, err := cw.WriteString(string("body")); err != nil {
11913 return err
11914 }
11915
11916 if len(t.Body) > 1000000 {
11917 return xerrors.Errorf("Value in field t.Body was too long")
11918 }
11919
11920 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
11921 return err
11922 }
11923 if _, err := cw.WriteString(string(t.Body)); err != nil {
11924 return err
11925 }
11926
11927 // t.LexiconTypeID (string) (string)
11928 if len("$type") > 1000000 {
11929 return xerrors.Errorf("Value in field \"$type\" was too long")
11930 }
11931
11932 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
11933 return err
11934 }
11935 if _, err := cw.WriteString(string("$type")); err != nil {
11936 return err
11937 }
11938
11939 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil {
11940 return err
11941 }
11942 if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil {
11943 return err
11944 }
11945
11946 // t.Issue (string) (string)
11947 if len("issue") > 1000000 {
11948 return xerrors.Errorf("Value in field \"issue\" was too long")
11949 }
11950
11951 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
11952 return err
11953 }
11954 if _, err := cw.WriteString(string("issue")); err != nil {
11955 return err
11956 }
11957
11958 if len(t.Issue) > 1000000 {
11959 return xerrors.Errorf("Value in field t.Issue was too long")
11960 }
11961
11962 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
11963 return err
11964 }
11965 if _, err := cw.WriteString(string(t.Issue)); err != nil {
11966 return err
11967 }
11968
11969 // t.ReplyTo (string) (string)
11970 if t.ReplyTo != nil {
11971
11972 if len("replyTo") > 1000000 {
11973 return xerrors.Errorf("Value in field \"replyTo\" was too long")
11974 }
11975
11976 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("replyTo"))); err != nil {
11977 return err
11978 }
11979 if _, err := cw.WriteString(string("replyTo")); err != nil {
11980 return err
11981 }
11982
11983 if t.ReplyTo == nil {
11984 if _, err := cw.Write(cbg.CborNull); err != nil {
11985 return err
11986 }
11987 } else {
11988 if len(*t.ReplyTo) > 1000000 {
11989 return xerrors.Errorf("Value in field t.ReplyTo was too long")
11990 }
11991
11992 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ReplyTo))); err != nil {
11993 return err
11994 }
11995 if _, err := cw.WriteString(string(*t.ReplyTo)); err != nil {
11996 return err
11997 }
11998 }
11999 }
12000
12001 // t.Mentions ([]string) (slice)
12002 if t.Mentions != nil {
12003
12004 if len("mentions") > 1000000 {
12005 return xerrors.Errorf("Value in field \"mentions\" was too long")
12006 }
12007
12008 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
12009 return err
12010 }
12011 if _, err := cw.WriteString(string("mentions")); err != nil {
12012 return err
12013 }
12014
12015 if len(t.Mentions) > 8192 {
12016 return xerrors.Errorf("Slice value in field t.Mentions was too long")
12017 }
12018
12019 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
12020 return err
12021 }
12022 for _, v := range t.Mentions {
12023 if len(v) > 1000000 {
12024 return xerrors.Errorf("Value in field v was too long")
12025 }
12026
12027 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
12028 return err
12029 }
12030 if _, err := cw.WriteString(string(v)); err != nil {
12031 return err
12032 }
12033
12034 }
12035 }
12036
12037 // t.CreatedAt (string) (string)
12038 if len("createdAt") > 1000000 {
12039 return xerrors.Errorf("Value in field \"createdAt\" was too long")
12040 }
12041
12042 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
12043 return err
12044 }
12045 if _, err := cw.WriteString(string("createdAt")); err != nil {
12046 return err
12047 }
12048
12049 if len(t.CreatedAt) > 1000000 {
12050 return xerrors.Errorf("Value in field t.CreatedAt was too long")
12051 }
12052
12053 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
12054 return err
12055 }
12056 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
12057 return err
12058 }
12059
12060 // t.References ([]string) (slice)
12061 if t.References != nil {
12062
12063 if len("references") > 1000000 {
12064 return xerrors.Errorf("Value in field \"references\" was too long")
12065 }
12066
12067 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
12068 return err
12069 }
12070 if _, err := cw.WriteString(string("references")); err != nil {
12071 return err
12072 }
12073
12074 if len(t.References) > 8192 {
12075 return xerrors.Errorf("Slice value in field t.References was too long")
12076 }
12077
12078 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
12079 return err
12080 }
12081 for _, v := range t.References {
12082 if len(v) > 1000000 {
12083 return xerrors.Errorf("Value in field v was too long")
12084 }
12085
12086 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
12087 return err
12088 }
12089 if _, err := cw.WriteString(string(v)); err != nil {
12090 return err
12091 }
12092
12093 }
12094 }
12095 return nil
12096}
12097
12098func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) {
12099 *t = RepoIssueComment{}
12100
12101 cr := cbg.NewCborReader(r)
12102
12103 maj, extra, err := cr.ReadHeader()
12104 if err != nil {
12105 return err
12106 }
12107 defer func() {
12108 if err == io.EOF {
12109 err = io.ErrUnexpectedEOF
12110 }
12111 }()
12112
12113 if maj != cbg.MajMap {
12114 return fmt.Errorf("cbor input should be of type map")
12115 }
12116
12117 if extra > cbg.MaxLength {
12118 return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra)
12119 }
12120
12121 n := extra
12122
12123 nameBuf := make([]byte, 10)
12124 for i := uint64(0); i < n; i++ {
12125 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
12126 if err != nil {
12127 return err
12128 }
12129
12130 if !ok {
12131 // Field doesn't exist on this type, so ignore it
12132 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
12133 return err
12134 }
12135 continue
12136 }
12137
12138 switch string(nameBuf[:nameLen]) {
12139 // t.Body (string) (string)
12140 case "body":
12141
12142 {
12143 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12144 if err != nil {
12145 return err
12146 }
12147
12148 t.Body = string(sval)
12149 }
12150 // t.LexiconTypeID (string) (string)
12151 case "$type":
12152
12153 {
12154 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12155 if err != nil {
12156 return err
12157 }
12158
12159 t.LexiconTypeID = string(sval)
12160 }
12161 // t.Issue (string) (string)
12162 case "issue":
12163
12164 {
12165 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12166 if err != nil {
12167 return err
12168 }
12169
12170 t.Issue = string(sval)
12171 }
12172 // t.ReplyTo (string) (string)
12173 case "replyTo":
12174
12175 {
12176 b, err := cr.ReadByte()
12177 if err != nil {
12178 return err
12179 }
12180 if b != cbg.CborNull[0] {
12181 if err := cr.UnreadByte(); err != nil {
12182 return err
12183 }
12184
12185 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12186 if err != nil {
12187 return err
12188 }
12189
12190 t.ReplyTo = (*string)(&sval)
12191 }
12192 }
12193 // t.Mentions ([]string) (slice)
12194 case "mentions":
12195
12196 maj, extra, err = cr.ReadHeader()
12197 if err != nil {
12198 return err
12199 }
12200
12201 if extra > 8192 {
12202 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
12203 }
12204
12205 if maj != cbg.MajArray {
12206 return fmt.Errorf("expected cbor array")
12207 }
12208
12209 if extra > 0 {
12210 t.Mentions = make([]string, extra)
12211 }
12212
12213 for i := 0; i < int(extra); i++ {
12214 {
12215 var maj byte
12216 var extra uint64
12217 var err error
12218 _ = maj
12219 _ = extra
12220 _ = err
12221
12222 {
12223 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12224 if err != nil {
12225 return err
12226 }
12227
12228 t.Mentions[i] = string(sval)
12229 }
12230
12231 }
12232 }
12233 // t.CreatedAt (string) (string)
12234 case "createdAt":
12235
12236 {
12237 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12238 if err != nil {
12239 return err
12240 }
12241
12242 t.CreatedAt = string(sval)
12243 }
12244 // t.References ([]string) (slice)
12245 case "references":
12246
12247 maj, extra, err = cr.ReadHeader()
12248 if err != nil {
12249 return err
12250 }
12251
12252 if extra > 8192 {
12253 return fmt.Errorf("t.References: array too large (%d)", extra)
12254 }
12255
12256 if maj != cbg.MajArray {
12257 return fmt.Errorf("expected cbor array")
12258 }
12259
12260 if extra > 0 {
12261 t.References = make([]string, extra)
12262 }
12263
12264 for i := 0; i < int(extra); i++ {
12265 {
12266 var maj byte
12267 var extra uint64
12268 var err error
12269 _ = maj
12270 _ = extra
12271 _ = err
12272
12273 {
12274 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12275 if err != nil {
12276 return err
12277 }
12278
12279 t.References[i] = string(sval)
12280 }
12281
12282 }
12283 }
12284
12285 default:
12286 // Field doesn't exist on this type, so ignore it
12287 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
12288 return err
12289 }
12290 }
12291 }
12292
12293 return nil
12294}
12295func (t *RepoIssueState) MarshalCBOR(w io.Writer) error {
12296 if t == nil {
12297 _, err := w.Write(cbg.CborNull)
12298 return err
12299 }
12300
12301 cw := cbg.NewCborWriter(w)
12302
12303 if _, err := cw.Write([]byte{164}); err != nil {
12304 return err
12305 }
12306
12307 // t.LexiconTypeID (string) (string)
12308 if len("$type") > 1000000 {
12309 return xerrors.Errorf("Value in field \"$type\" was too long")
12310 }
12311
12312 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
12313 return err
12314 }
12315 if _, err := cw.WriteString(string("$type")); err != nil {
12316 return err
12317 }
12318
12319 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil {
12320 return err
12321 }
12322 if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil {
12323 return err
12324 }
12325
12326 // t.Issue (string) (string)
12327 if len("issue") > 1000000 {
12328 return xerrors.Errorf("Value in field \"issue\" was too long")
12329 }
12330
12331 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
12332 return err
12333 }
12334 if _, err := cw.WriteString(string("issue")); err != nil {
12335 return err
12336 }
12337
12338 if len(t.Issue) > 1000000 {
12339 return xerrors.Errorf("Value in field t.Issue was too long")
12340 }
12341
12342 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
12343 return err
12344 }
12345 if _, err := cw.WriteString(string(t.Issue)); err != nil {
12346 return err
12347 }
12348
12349 // t.State (string) (string)
12350 if len("state") > 1000000 {
12351 return xerrors.Errorf("Value in field \"state\" was too long")
12352 }
12353
12354 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil {
12355 return err
12356 }
12357 if _, err := cw.WriteString(string("state")); err != nil {
12358 return err
12359 }
12360
12361 if len(t.State) > 1000000 {
12362 return xerrors.Errorf("Value in field t.State was too long")
12363 }
12364
12365 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil {
12366 return err
12367 }
12368 if _, err := cw.WriteString(string(t.State)); err != nil {
12369 return err
12370 }
12371
12372 // t.CreatedAt (string) (string)
12373 if len("createdAt") > 1000000 {
12374 return xerrors.Errorf("Value in field \"createdAt\" was too long")
12375 }
12376
12377 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
12378 return err
12379 }
12380 if _, err := cw.WriteString(string("createdAt")); err != nil {
12381 return err
12382 }
12383
12384 if len(t.CreatedAt) > 1000000 {
12385 return xerrors.Errorf("Value in field t.CreatedAt was too long")
12386 }
12387
12388 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
12389 return err
12390 }
12391 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
12392 return err
12393 }
12394 return nil
12395}
12396
12397func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) {
12398 *t = RepoIssueState{}
12399
12400 cr := cbg.NewCborReader(r)
12401
12402 maj, extra, err := cr.ReadHeader()
12403 if err != nil {
12404 return err
12405 }
12406 defer func() {
12407 if err == io.EOF {
12408 err = io.ErrUnexpectedEOF
12409 }
12410 }()
12411
12412 if maj != cbg.MajMap {
12413 return fmt.Errorf("cbor input should be of type map")
12414 }
12415
12416 if extra > cbg.MaxLength {
12417 return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra)
12418 }
12419
12420 n := extra
12421
12422 nameBuf := make([]byte, 9)
12423 for i := uint64(0); i < n; i++ {
12424 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
12425 if err != nil {
12426 return err
12427 }
12428
12429 if !ok {
12430 // Field doesn't exist on this type, so ignore it
12431 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
12432 return err
12433 }
12434 continue
12435 }
12436
12437 switch string(nameBuf[:nameLen]) {
12438 // t.LexiconTypeID (string) (string)
12439 case "$type":
12440
12441 {
12442 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12443 if err != nil {
12444 return err
12445 }
12446
12447 t.LexiconTypeID = string(sval)
12448 }
12449 // t.Issue (string) (string)
12450 case "issue":
12451
12452 {
12453 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12454 if err != nil {
12455 return err
12456 }
12457
12458 t.Issue = string(sval)
12459 }
12460 // t.State (string) (string)
12461 case "state":
12462
12463 {
12464 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12465 if err != nil {
12466 return err
12467 }
12468
12469 t.State = string(sval)
12470 }
12471 // t.CreatedAt (string) (string)
12472 case "createdAt":
12473
12474 {
12475 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12476 if err != nil {
12477 return err
12478 }
12479
12480 t.CreatedAt = string(sval)
12481 }
12482
12483 default:
12484 // Field doesn't exist on this type, so ignore it
12485 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
12486 return err
12487 }
12488 }
12489 }
12490
12491 return nil
12492}
12493func (t *RepoPull) MarshalCBOR(w io.Writer) error {
12494 if t == nil {
12495 _, err := w.Write(cbg.CborNull)
12496 return err
12497 }
12498
12499 cw := cbg.NewCborWriter(w)
12500 fieldCount := 10
12501
12502 if t.Body == nil {
12503 fieldCount--
12504 }
12505
12506 if t.DependentOn == nil {
12507 fieldCount--
12508 }
12509
12510 if t.Mentions == nil {
12511 fieldCount--
12512 }
12513
12514 if t.References == nil {
12515 fieldCount--
12516 }
12517
12518 if t.Source == nil {
12519 fieldCount--
12520 }
12521
12522 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
12523 return err
12524 }
12525
12526 // t.Body (string) (string)
12527 if t.Body != nil {
12528
12529 if len("body") > 1000000 {
12530 return xerrors.Errorf("Value in field \"body\" was too long")
12531 }
12532
12533 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
12534 return err
12535 }
12536 if _, err := cw.WriteString(string("body")); err != nil {
12537 return err
12538 }
12539
12540 if t.Body == nil {
12541 if _, err := cw.Write(cbg.CborNull); err != nil {
12542 return err
12543 }
12544 } else {
12545 if len(*t.Body) > 1000000 {
12546 return xerrors.Errorf("Value in field t.Body was too long")
12547 }
12548
12549 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
12550 return err
12551 }
12552 if _, err := cw.WriteString(string(*t.Body)); err != nil {
12553 return err
12554 }
12555 }
12556 }
12557
12558 // t.LexiconTypeID (string) (string)
12559 if len("$type") > 1000000 {
12560 return xerrors.Errorf("Value in field \"$type\" was too long")
12561 }
12562
12563 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
12564 return err
12565 }
12566 if _, err := cw.WriteString(string("$type")); err != nil {
12567 return err
12568 }
12569
12570 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil {
12571 return err
12572 }
12573 if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil {
12574 return err
12575 }
12576
12577 // t.Title (string) (string)
12578 if len("title") > 1000000 {
12579 return xerrors.Errorf("Value in field \"title\" was too long")
12580 }
12581
12582 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
12583 return err
12584 }
12585 if _, err := cw.WriteString(string("title")); err != nil {
12586 return err
12587 }
12588
12589 if len(t.Title) > 1000000 {
12590 return xerrors.Errorf("Value in field t.Title was too long")
12591 }
12592
12593 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
12594 return err
12595 }
12596 if _, err := cw.WriteString(string(t.Title)); err != nil {
12597 return err
12598 }
12599
12600 // t.Rounds ([]*tangled.RepoPull_Round) (slice)
12601 if len("rounds") > 1000000 {
12602 return xerrors.Errorf("Value in field \"rounds\" was too long")
12603 }
12604
12605 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("rounds"))); err != nil {
12606 return err
12607 }
12608 if _, err := cw.WriteString(string("rounds")); err != nil {
12609 return err
12610 }
12611
12612 if len(t.Rounds) > 8192 {
12613 return xerrors.Errorf("Slice value in field t.Rounds was too long")
12614 }
12615
12616 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Rounds))); err != nil {
12617 return err
12618 }
12619 for _, v := range t.Rounds {
12620 if err := v.MarshalCBOR(cw); err != nil {
12621 return err
12622 }
12623
12624 }
12625
12626 // t.Source (tangled.RepoPull_Source) (struct)
12627 if t.Source != nil {
12628
12629 if len("source") > 1000000 {
12630 return xerrors.Errorf("Value in field \"source\" was too long")
12631 }
12632
12633 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
12634 return err
12635 }
12636 if _, err := cw.WriteString(string("source")); err != nil {
12637 return err
12638 }
12639
12640 if err := t.Source.MarshalCBOR(cw); err != nil {
12641 return err
12642 }
12643 }
12644
12645 // t.Target (tangled.RepoPull_Target) (struct)
12646 if len("target") > 1000000 {
12647 return xerrors.Errorf("Value in field \"target\" was too long")
12648 }
12649
12650 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("target"))); err != nil {
12651 return err
12652 }
12653 if _, err := cw.WriteString(string("target")); err != nil {
12654 return err
12655 }
12656
12657 if err := t.Target.MarshalCBOR(cw); err != nil {
12658 return err
12659 }
12660
12661 // t.Mentions ([]string) (slice)
12662 if t.Mentions != nil {
12663
12664 if len("mentions") > 1000000 {
12665 return xerrors.Errorf("Value in field \"mentions\" was too long")
12666 }
12667
12668 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
12669 return err
12670 }
12671 if _, err := cw.WriteString(string("mentions")); err != nil {
12672 return err
12673 }
12674
12675 if len(t.Mentions) > 8192 {
12676 return xerrors.Errorf("Slice value in field t.Mentions was too long")
12677 }
12678
12679 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
12680 return err
12681 }
12682 for _, v := range t.Mentions {
12683 if len(v) > 1000000 {
12684 return xerrors.Errorf("Value in field v was too long")
12685 }
12686
12687 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
12688 return err
12689 }
12690 if _, err := cw.WriteString(string(v)); err != nil {
12691 return err
12692 }
12693
12694 }
12695 }
12696
12697 // t.CreatedAt (string) (string)
12698 if len("createdAt") > 1000000 {
12699 return xerrors.Errorf("Value in field \"createdAt\" was too long")
12700 }
12701
12702 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
12703 return err
12704 }
12705 if _, err := cw.WriteString(string("createdAt")); err != nil {
12706 return err
12707 }
12708
12709 if len(t.CreatedAt) > 1000000 {
12710 return xerrors.Errorf("Value in field t.CreatedAt was too long")
12711 }
12712
12713 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
12714 return err
12715 }
12716 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
12717 return err
12718 }
12719
12720 // t.References ([]string) (slice)
12721 if t.References != nil {
12722
12723 if len("references") > 1000000 {
12724 return xerrors.Errorf("Value in field \"references\" was too long")
12725 }
12726
12727 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
12728 return err
12729 }
12730 if _, err := cw.WriteString(string("references")); err != nil {
12731 return err
12732 }
12733
12734 if len(t.References) > 8192 {
12735 return xerrors.Errorf("Slice value in field t.References was too long")
12736 }
12737
12738 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
12739 return err
12740 }
12741 for _, v := range t.References {
12742 if len(v) > 1000000 {
12743 return xerrors.Errorf("Value in field v was too long")
12744 }
12745
12746 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
12747 return err
12748 }
12749 if _, err := cw.WriteString(string(v)); err != nil {
12750 return err
12751 }
12752
12753 }
12754 }
12755
12756 // t.DependentOn (string) (string)
12757 if t.DependentOn != nil {
12758
12759 if len("dependentOn") > 1000000 {
12760 return xerrors.Errorf("Value in field \"dependentOn\" was too long")
12761 }
12762
12763 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("dependentOn"))); err != nil {
12764 return err
12765 }
12766 if _, err := cw.WriteString(string("dependentOn")); err != nil {
12767 return err
12768 }
12769
12770 if t.DependentOn == nil {
12771 if _, err := cw.Write(cbg.CborNull); err != nil {
12772 return err
12773 }
12774 } else {
12775 if len(*t.DependentOn) > 1000000 {
12776 return xerrors.Errorf("Value in field t.DependentOn was too long")
12777 }
12778
12779 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.DependentOn))); err != nil {
12780 return err
12781 }
12782 if _, err := cw.WriteString(string(*t.DependentOn)); err != nil {
12783 return err
12784 }
12785 }
12786 }
12787 return nil
12788}
12789
12790func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) {
12791 *t = RepoPull{}
12792
12793 cr := cbg.NewCborReader(r)
12794
12795 maj, extra, err := cr.ReadHeader()
12796 if err != nil {
12797 return err
12798 }
12799 defer func() {
12800 if err == io.EOF {
12801 err = io.ErrUnexpectedEOF
12802 }
12803 }()
12804
12805 if maj != cbg.MajMap {
12806 return fmt.Errorf("cbor input should be of type map")
12807 }
12808
12809 if extra > cbg.MaxLength {
12810 return fmt.Errorf("RepoPull: map struct too large (%d)", extra)
12811 }
12812
12813 n := extra
12814
12815 nameBuf := make([]byte, 11)
12816 for i := uint64(0); i < n; i++ {
12817 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
12818 if err != nil {
12819 return err
12820 }
12821
12822 if !ok {
12823 // Field doesn't exist on this type, so ignore it
12824 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
12825 return err
12826 }
12827 continue
12828 }
12829
12830 switch string(nameBuf[:nameLen]) {
12831 // t.Body (string) (string)
12832 case "body":
12833
12834 {
12835 b, err := cr.ReadByte()
12836 if err != nil {
12837 return err
12838 }
12839 if b != cbg.CborNull[0] {
12840 if err := cr.UnreadByte(); err != nil {
12841 return err
12842 }
12843
12844 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12845 if err != nil {
12846 return err
12847 }
12848
12849 t.Body = (*string)(&sval)
12850 }
12851 }
12852 // t.LexiconTypeID (string) (string)
12853 case "$type":
12854
12855 {
12856 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12857 if err != nil {
12858 return err
12859 }
12860
12861 t.LexiconTypeID = string(sval)
12862 }
12863 // t.Title (string) (string)
12864 case "title":
12865
12866 {
12867 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12868 if err != nil {
12869 return err
12870 }
12871
12872 t.Title = string(sval)
12873 }
12874 // t.Rounds ([]*tangled.RepoPull_Round) (slice)
12875 case "rounds":
12876
12877 maj, extra, err = cr.ReadHeader()
12878 if err != nil {
12879 return err
12880 }
12881
12882 if extra > 8192 {
12883 return fmt.Errorf("t.Rounds: array too large (%d)", extra)
12884 }
12885
12886 if maj != cbg.MajArray {
12887 return fmt.Errorf("expected cbor array")
12888 }
12889
12890 if extra > 0 {
12891 t.Rounds = make([]*RepoPull_Round, extra)
12892 }
12893
12894 for i := 0; i < int(extra); i++ {
12895 {
12896 var maj byte
12897 var extra uint64
12898 var err error
12899 _ = maj
12900 _ = extra
12901 _ = err
12902
12903 {
12904
12905 b, err := cr.ReadByte()
12906 if err != nil {
12907 return err
12908 }
12909 if b != cbg.CborNull[0] {
12910 if err := cr.UnreadByte(); err != nil {
12911 return err
12912 }
12913 t.Rounds[i] = new(RepoPull_Round)
12914 if err := t.Rounds[i].UnmarshalCBOR(cr); err != nil {
12915 return xerrors.Errorf("unmarshaling t.Rounds[i] pointer: %w", err)
12916 }
12917 }
12918
12919 }
12920
12921 }
12922 }
12923 // t.Source (tangled.RepoPull_Source) (struct)
12924 case "source":
12925
12926 {
12927
12928 b, err := cr.ReadByte()
12929 if err != nil {
12930 return err
12931 }
12932 if b != cbg.CborNull[0] {
12933 if err := cr.UnreadByte(); err != nil {
12934 return err
12935 }
12936 t.Source = new(RepoPull_Source)
12937 if err := t.Source.UnmarshalCBOR(cr); err != nil {
12938 return xerrors.Errorf("unmarshaling t.Source pointer: %w", err)
12939 }
12940 }
12941
12942 }
12943 // t.Target (tangled.RepoPull_Target) (struct)
12944 case "target":
12945
12946 {
12947
12948 b, err := cr.ReadByte()
12949 if err != nil {
12950 return err
12951 }
12952 if b != cbg.CborNull[0] {
12953 if err := cr.UnreadByte(); err != nil {
12954 return err
12955 }
12956 t.Target = new(RepoPull_Target)
12957 if err := t.Target.UnmarshalCBOR(cr); err != nil {
12958 return xerrors.Errorf("unmarshaling t.Target pointer: %w", err)
12959 }
12960 }
12961
12962 }
12963 // t.Mentions ([]string) (slice)
12964 case "mentions":
12965
12966 maj, extra, err = cr.ReadHeader()
12967 if err != nil {
12968 return err
12969 }
12970
12971 if extra > 8192 {
12972 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
12973 }
12974
12975 if maj != cbg.MajArray {
12976 return fmt.Errorf("expected cbor array")
12977 }
12978
12979 if extra > 0 {
12980 t.Mentions = make([]string, extra)
12981 }
12982
12983 for i := 0; i < int(extra); i++ {
12984 {
12985 var maj byte
12986 var extra uint64
12987 var err error
12988 _ = maj
12989 _ = extra
12990 _ = err
12991
12992 {
12993 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12994 if err != nil {
12995 return err
12996 }
12997
12998 t.Mentions[i] = string(sval)
12999 }
13000
13001 }
13002 }
13003 // t.CreatedAt (string) (string)
13004 case "createdAt":
13005
13006 {
13007 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13008 if err != nil {
13009 return err
13010 }
13011
13012 t.CreatedAt = string(sval)
13013 }
13014 // t.References ([]string) (slice)
13015 case "references":
13016
13017 maj, extra, err = cr.ReadHeader()
13018 if err != nil {
13019 return err
13020 }
13021
13022 if extra > 8192 {
13023 return fmt.Errorf("t.References: array too large (%d)", extra)
13024 }
13025
13026 if maj != cbg.MajArray {
13027 return fmt.Errorf("expected cbor array")
13028 }
13029
13030 if extra > 0 {
13031 t.References = make([]string, extra)
13032 }
13033
13034 for i := 0; i < int(extra); i++ {
13035 {
13036 var maj byte
13037 var extra uint64
13038 var err error
13039 _ = maj
13040 _ = extra
13041 _ = err
13042
13043 {
13044 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13045 if err != nil {
13046 return err
13047 }
13048
13049 t.References[i] = string(sval)
13050 }
13051
13052 }
13053 }
13054 // t.DependentOn (string) (string)
13055 case "dependentOn":
13056
13057 {
13058 b, err := cr.ReadByte()
13059 if err != nil {
13060 return err
13061 }
13062 if b != cbg.CborNull[0] {
13063 if err := cr.UnreadByte(); err != nil {
13064 return err
13065 }
13066
13067 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13068 if err != nil {
13069 return err
13070 }
13071
13072 t.DependentOn = (*string)(&sval)
13073 }
13074 }
13075
13076 default:
13077 // Field doesn't exist on this type, so ignore it
13078 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
13079 return err
13080 }
13081 }
13082 }
13083
13084 return nil
13085}
13086func (t *RepoPullComment) MarshalCBOR(w io.Writer) error {
13087 if t == nil {
13088 _, err := w.Write(cbg.CborNull)
13089 return err
13090 }
13091
13092 cw := cbg.NewCborWriter(w)
13093 fieldCount := 6
13094
13095 if t.Mentions == nil {
13096 fieldCount--
13097 }
13098
13099 if t.References == nil {
13100 fieldCount--
13101 }
13102
13103 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
13104 return err
13105 }
13106
13107 // t.Body (string) (string)
13108 if len("body") > 1000000 {
13109 return xerrors.Errorf("Value in field \"body\" was too long")
13110 }
13111
13112 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
13113 return err
13114 }
13115 if _, err := cw.WriteString(string("body")); err != nil {
13116 return err
13117 }
13118
13119 if len(t.Body) > 1000000 {
13120 return xerrors.Errorf("Value in field t.Body was too long")
13121 }
13122
13123 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
13124 return err
13125 }
13126 if _, err := cw.WriteString(string(t.Body)); err != nil {
13127 return err
13128 }
13129
13130 // t.Pull (string) (string)
13131 if len("pull") > 1000000 {
13132 return xerrors.Errorf("Value in field \"pull\" was too long")
13133 }
13134
13135 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
13136 return err
13137 }
13138 if _, err := cw.WriteString(string("pull")); err != nil {
13139 return err
13140 }
13141
13142 if len(t.Pull) > 1000000 {
13143 return xerrors.Errorf("Value in field t.Pull was too long")
13144 }
13145
13146 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
13147 return err
13148 }
13149 if _, err := cw.WriteString(string(t.Pull)); err != nil {
13150 return err
13151 }
13152
13153 // t.LexiconTypeID (string) (string)
13154 if len("$type") > 1000000 {
13155 return xerrors.Errorf("Value in field \"$type\" was too long")
13156 }
13157
13158 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
13159 return err
13160 }
13161 if _, err := cw.WriteString(string("$type")); err != nil {
13162 return err
13163 }
13164
13165 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.comment"))); err != nil {
13166 return err
13167 }
13168 if _, err := cw.WriteString(string("sh.tangled.repo.pull.comment")); err != nil {
13169 return err
13170 }
13171
13172 // t.Mentions ([]string) (slice)
13173 if t.Mentions != nil {
13174
13175 if len("mentions") > 1000000 {
13176 return xerrors.Errorf("Value in field \"mentions\" was too long")
13177 }
13178
13179 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
13180 return err
13181 }
13182 if _, err := cw.WriteString(string("mentions")); err != nil {
13183 return err
13184 }
13185
13186 if len(t.Mentions) > 8192 {
13187 return xerrors.Errorf("Slice value in field t.Mentions was too long")
13188 }
13189
13190 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
13191 return err
13192 }
13193 for _, v := range t.Mentions {
13194 if len(v) > 1000000 {
13195 return xerrors.Errorf("Value in field v was too long")
13196 }
13197
13198 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
13199 return err
13200 }
13201 if _, err := cw.WriteString(string(v)); err != nil {
13202 return err
13203 }
13204
13205 }
13206 }
13207
13208 // t.CreatedAt (string) (string)
13209 if len("createdAt") > 1000000 {
13210 return xerrors.Errorf("Value in field \"createdAt\" was too long")
13211 }
13212
13213 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
13214 return err
13215 }
13216 if _, err := cw.WriteString(string("createdAt")); err != nil {
13217 return err
13218 }
13219
13220 if len(t.CreatedAt) > 1000000 {
13221 return xerrors.Errorf("Value in field t.CreatedAt was too long")
13222 }
13223
13224 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
13225 return err
13226 }
13227 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
13228 return err
13229 }
13230
13231 // t.References ([]string) (slice)
13232 if t.References != nil {
13233
13234 if len("references") > 1000000 {
13235 return xerrors.Errorf("Value in field \"references\" was too long")
13236 }
13237
13238 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
13239 return err
13240 }
13241 if _, err := cw.WriteString(string("references")); err != nil {
13242 return err
13243 }
13244
13245 if len(t.References) > 8192 {
13246 return xerrors.Errorf("Slice value in field t.References was too long")
13247 }
13248
13249 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
13250 return err
13251 }
13252 for _, v := range t.References {
13253 if len(v) > 1000000 {
13254 return xerrors.Errorf("Value in field v was too long")
13255 }
13256
13257 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
13258 return err
13259 }
13260 if _, err := cw.WriteString(string(v)); err != nil {
13261 return err
13262 }
13263
13264 }
13265 }
13266 return nil
13267}
13268
13269func (t *RepoPullComment) UnmarshalCBOR(r io.Reader) (err error) {
13270 *t = RepoPullComment{}
13271
13272 cr := cbg.NewCborReader(r)
13273
13274 maj, extra, err := cr.ReadHeader()
13275 if err != nil {
13276 return err
13277 }
13278 defer func() {
13279 if err == io.EOF {
13280 err = io.ErrUnexpectedEOF
13281 }
13282 }()
13283
13284 if maj != cbg.MajMap {
13285 return fmt.Errorf("cbor input should be of type map")
13286 }
13287
13288 if extra > cbg.MaxLength {
13289 return fmt.Errorf("RepoPullComment: map struct too large (%d)", extra)
13290 }
13291
13292 n := extra
13293
13294 nameBuf := make([]byte, 10)
13295 for i := uint64(0); i < n; i++ {
13296 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
13297 if err != nil {
13298 return err
13299 }
13300
13301 if !ok {
13302 // Field doesn't exist on this type, so ignore it
13303 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
13304 return err
13305 }
13306 continue
13307 }
13308
13309 switch string(nameBuf[:nameLen]) {
13310 // t.Body (string) (string)
13311 case "body":
13312
13313 {
13314 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13315 if err != nil {
13316 return err
13317 }
13318
13319 t.Body = string(sval)
13320 }
13321 // t.Pull (string) (string)
13322 case "pull":
13323
13324 {
13325 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13326 if err != nil {
13327 return err
13328 }
13329
13330 t.Pull = string(sval)
13331 }
13332 // t.LexiconTypeID (string) (string)
13333 case "$type":
13334
13335 {
13336 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13337 if err != nil {
13338 return err
13339 }
13340
13341 t.LexiconTypeID = string(sval)
13342 }
13343 // t.Mentions ([]string) (slice)
13344 case "mentions":
13345
13346 maj, extra, err = cr.ReadHeader()
13347 if err != nil {
13348 return err
13349 }
13350
13351 if extra > 8192 {
13352 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
13353 }
13354
13355 if maj != cbg.MajArray {
13356 return fmt.Errorf("expected cbor array")
13357 }
13358
13359 if extra > 0 {
13360 t.Mentions = make([]string, extra)
13361 }
13362
13363 for i := 0; i < int(extra); i++ {
13364 {
13365 var maj byte
13366 var extra uint64
13367 var err error
13368 _ = maj
13369 _ = extra
13370 _ = err
13371
13372 {
13373 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13374 if err != nil {
13375 return err
13376 }
13377
13378 t.Mentions[i] = string(sval)
13379 }
13380
13381 }
13382 }
13383 // t.CreatedAt (string) (string)
13384 case "createdAt":
13385
13386 {
13387 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13388 if err != nil {
13389 return err
13390 }
13391
13392 t.CreatedAt = string(sval)
13393 }
13394 // t.References ([]string) (slice)
13395 case "references":
13396
13397 maj, extra, err = cr.ReadHeader()
13398 if err != nil {
13399 return err
13400 }
13401
13402 if extra > 8192 {
13403 return fmt.Errorf("t.References: array too large (%d)", extra)
13404 }
13405
13406 if maj != cbg.MajArray {
13407 return fmt.Errorf("expected cbor array")
13408 }
13409
13410 if extra > 0 {
13411 t.References = make([]string, extra)
13412 }
13413
13414 for i := 0; i < int(extra); i++ {
13415 {
13416 var maj byte
13417 var extra uint64
13418 var err error
13419 _ = maj
13420 _ = extra
13421 _ = err
13422
13423 {
13424 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13425 if err != nil {
13426 return err
13427 }
13428
13429 t.References[i] = string(sval)
13430 }
13431
13432 }
13433 }
13434
13435 default:
13436 // Field doesn't exist on this type, so ignore it
13437 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
13438 return err
13439 }
13440 }
13441 }
13442
13443 return nil
13444}
13445func (t *RepoPull_Round) MarshalCBOR(w io.Writer) error {
13446 if t == nil {
13447 _, err := w.Write(cbg.CborNull)
13448 return err
13449 }
13450
13451 cw := cbg.NewCborWriter(w)
13452
13453 if _, err := cw.Write([]byte{162}); err != nil {
13454 return err
13455 }
13456
13457 // t.CreatedAt (string) (string)
13458 if len("createdAt") > 1000000 {
13459 return xerrors.Errorf("Value in field \"createdAt\" was too long")
13460 }
13461
13462 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
13463 return err
13464 }
13465 if _, err := cw.WriteString(string("createdAt")); err != nil {
13466 return err
13467 }
13468
13469 if len(t.CreatedAt) > 1000000 {
13470 return xerrors.Errorf("Value in field t.CreatedAt was too long")
13471 }
13472
13473 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
13474 return err
13475 }
13476 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
13477 return err
13478 }
13479
13480 // t.PatchBlob (util.LexBlob) (struct)
13481 if len("patchBlob") > 1000000 {
13482 return xerrors.Errorf("Value in field \"patchBlob\" was too long")
13483 }
13484
13485 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patchBlob"))); err != nil {
13486 return err
13487 }
13488 if _, err := cw.WriteString(string("patchBlob")); err != nil {
13489 return err
13490 }
13491
13492 if err := t.PatchBlob.MarshalCBOR(cw); err != nil {
13493 return err
13494 }
13495 return nil
13496}
13497
13498func (t *RepoPull_Round) UnmarshalCBOR(r io.Reader) (err error) {
13499 *t = RepoPull_Round{}
13500
13501 cr := cbg.NewCborReader(r)
13502
13503 maj, extra, err := cr.ReadHeader()
13504 if err != nil {
13505 return err
13506 }
13507 defer func() {
13508 if err == io.EOF {
13509 err = io.ErrUnexpectedEOF
13510 }
13511 }()
13512
13513 if maj != cbg.MajMap {
13514 return fmt.Errorf("cbor input should be of type map")
13515 }
13516
13517 if extra > cbg.MaxLength {
13518 return fmt.Errorf("RepoPull_Round: map struct too large (%d)", extra)
13519 }
13520
13521 n := extra
13522
13523 nameBuf := make([]byte, 9)
13524 for i := uint64(0); i < n; i++ {
13525 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
13526 if err != nil {
13527 return err
13528 }
13529
13530 if !ok {
13531 // Field doesn't exist on this type, so ignore it
13532 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
13533 return err
13534 }
13535 continue
13536 }
13537
13538 switch string(nameBuf[:nameLen]) {
13539 // t.CreatedAt (string) (string)
13540 case "createdAt":
13541
13542 {
13543 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13544 if err != nil {
13545 return err
13546 }
13547
13548 t.CreatedAt = string(sval)
13549 }
13550 // t.PatchBlob (util.LexBlob) (struct)
13551 case "patchBlob":
13552
13553 {
13554
13555 b, err := cr.ReadByte()
13556 if err != nil {
13557 return err
13558 }
13559 if b != cbg.CborNull[0] {
13560 if err := cr.UnreadByte(); err != nil {
13561 return err
13562 }
13563 t.PatchBlob = new(util.LexBlob)
13564 if err := t.PatchBlob.UnmarshalCBOR(cr); err != nil {
13565 return xerrors.Errorf("unmarshaling t.PatchBlob pointer: %w", err)
13566 }
13567 }
13568
13569 }
13570
13571 default:
13572 // Field doesn't exist on this type, so ignore it
13573 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
13574 return err
13575 }
13576 }
13577 }
13578
13579 return nil
13580}
13581func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error {
13582 if t == nil {
13583 _, err := w.Write(cbg.CborNull)
13584 return err
13585 }
13586
13587 cw := cbg.NewCborWriter(w)
13588 fieldCount := 2
13589
13590 if t.Repo == nil {
13591 fieldCount--
13592 }
13593
13594 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
13595 return err
13596 }
13597
13598 // t.Repo (string) (string)
13599 if t.Repo != nil {
13600
13601 if len("repo") > 1000000 {
13602 return xerrors.Errorf("Value in field \"repo\" was too long")
13603 }
13604
13605 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
13606 return err
13607 }
13608 if _, err := cw.WriteString(string("repo")); err != nil {
13609 return err
13610 }
13611
13612 if t.Repo == nil {
13613 if _, err := cw.Write(cbg.CborNull); err != nil {
13614 return err
13615 }
13616 } else {
13617 if len(*t.Repo) > 1000000 {
13618 return xerrors.Errorf("Value in field t.Repo was too long")
13619 }
13620
13621 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
13622 return err
13623 }
13624 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
13625 return err
13626 }
13627 }
13628 }
13629
13630 // t.Branch (string) (string)
13631 if len("branch") > 1000000 {
13632 return xerrors.Errorf("Value in field \"branch\" was too long")
13633 }
13634
13635 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
13636 return err
13637 }
13638 if _, err := cw.WriteString(string("branch")); err != nil {
13639 return err
13640 }
13641
13642 if len(t.Branch) > 1000000 {
13643 return xerrors.Errorf("Value in field t.Branch was too long")
13644 }
13645
13646 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
13647 return err
13648 }
13649 if _, err := cw.WriteString(string(t.Branch)); err != nil {
13650 return err
13651 }
13652 return nil
13653}
13654
13655func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) {
13656 *t = RepoPull_Source{}
13657
13658 cr := cbg.NewCborReader(r)
13659
13660 maj, extra, err := cr.ReadHeader()
13661 if err != nil {
13662 return err
13663 }
13664 defer func() {
13665 if err == io.EOF {
13666 err = io.ErrUnexpectedEOF
13667 }
13668 }()
13669
13670 if maj != cbg.MajMap {
13671 return fmt.Errorf("cbor input should be of type map")
13672 }
13673
13674 if extra > cbg.MaxLength {
13675 return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra)
13676 }
13677
13678 n := extra
13679
13680 nameBuf := make([]byte, 6)
13681 for i := uint64(0); i < n; i++ {
13682 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
13683 if err != nil {
13684 return err
13685 }
13686
13687 if !ok {
13688 // Field doesn't exist on this type, so ignore it
13689 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
13690 return err
13691 }
13692 continue
13693 }
13694
13695 switch string(nameBuf[:nameLen]) {
13696 // t.Repo (string) (string)
13697 case "repo":
13698
13699 {
13700 b, err := cr.ReadByte()
13701 if err != nil {
13702 return err
13703 }
13704 if b != cbg.CborNull[0] {
13705 if err := cr.UnreadByte(); err != nil {
13706 return err
13707 }
13708
13709 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13710 if err != nil {
13711 return err
13712 }
13713
13714 t.Repo = (*string)(&sval)
13715 }
13716 }
13717 // t.Branch (string) (string)
13718 case "branch":
13719
13720 {
13721 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13722 if err != nil {
13723 return err
13724 }
13725
13726 t.Branch = string(sval)
13727 }
13728
13729 default:
13730 // Field doesn't exist on this type, so ignore it
13731 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
13732 return err
13733 }
13734 }
13735 }
13736
13737 return nil
13738}
13739func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error {
13740 if t == nil {
13741 _, err := w.Write(cbg.CborNull)
13742 return err
13743 }
13744
13745 cw := cbg.NewCborWriter(w)
13746
13747 if _, err := cw.Write([]byte{164}); err != nil {
13748 return err
13749 }
13750
13751 // t.Pull (string) (string)
13752 if len("pull") > 1000000 {
13753 return xerrors.Errorf("Value in field \"pull\" was too long")
13754 }
13755
13756 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
13757 return err
13758 }
13759 if _, err := cw.WriteString(string("pull")); err != nil {
13760 return err
13761 }
13762
13763 if len(t.Pull) > 1000000 {
13764 return xerrors.Errorf("Value in field t.Pull was too long")
13765 }
13766
13767 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
13768 return err
13769 }
13770 if _, err := cw.WriteString(string(t.Pull)); err != nil {
13771 return err
13772 }
13773
13774 // t.LexiconTypeID (string) (string)
13775 if len("$type") > 1000000 {
13776 return xerrors.Errorf("Value in field \"$type\" was too long")
13777 }
13778
13779 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
13780 return err
13781 }
13782 if _, err := cw.WriteString(string("$type")); err != nil {
13783 return err
13784 }
13785
13786 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil {
13787 return err
13788 }
13789 if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil {
13790 return err
13791 }
13792
13793 // t.Status (string) (string)
13794 if len("status") > 1000000 {
13795 return xerrors.Errorf("Value in field \"status\" was too long")
13796 }
13797
13798 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
13799 return err
13800 }
13801 if _, err := cw.WriteString(string("status")); err != nil {
13802 return err
13803 }
13804
13805 if len(t.Status) > 1000000 {
13806 return xerrors.Errorf("Value in field t.Status was too long")
13807 }
13808
13809 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
13810 return err
13811 }
13812 if _, err := cw.WriteString(string(t.Status)); err != nil {
13813 return err
13814 }
13815
13816 // t.CreatedAt (string) (string)
13817 if len("createdAt") > 1000000 {
13818 return xerrors.Errorf("Value in field \"createdAt\" was too long")
13819 }
13820
13821 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
13822 return err
13823 }
13824 if _, err := cw.WriteString(string("createdAt")); err != nil {
13825 return err
13826 }
13827
13828 if len(t.CreatedAt) > 1000000 {
13829 return xerrors.Errorf("Value in field t.CreatedAt was too long")
13830 }
13831
13832 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
13833 return err
13834 }
13835 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
13836 return err
13837 }
13838 return nil
13839}
13840
13841func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) {
13842 *t = RepoPullStatus{}
13843
13844 cr := cbg.NewCborReader(r)
13845
13846 maj, extra, err := cr.ReadHeader()
13847 if err != nil {
13848 return err
13849 }
13850 defer func() {
13851 if err == io.EOF {
13852 err = io.ErrUnexpectedEOF
13853 }
13854 }()
13855
13856 if maj != cbg.MajMap {
13857 return fmt.Errorf("cbor input should be of type map")
13858 }
13859
13860 if extra > cbg.MaxLength {
13861 return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra)
13862 }
13863
13864 n := extra
13865
13866 nameBuf := make([]byte, 9)
13867 for i := uint64(0); i < n; i++ {
13868 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
13869 if err != nil {
13870 return err
13871 }
13872
13873 if !ok {
13874 // Field doesn't exist on this type, so ignore it
13875 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
13876 return err
13877 }
13878 continue
13879 }
13880
13881 switch string(nameBuf[:nameLen]) {
13882 // t.Pull (string) (string)
13883 case "pull":
13884
13885 {
13886 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13887 if err != nil {
13888 return err
13889 }
13890
13891 t.Pull = string(sval)
13892 }
13893 // t.LexiconTypeID (string) (string)
13894 case "$type":
13895
13896 {
13897 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13898 if err != nil {
13899 return err
13900 }
13901
13902 t.LexiconTypeID = string(sval)
13903 }
13904 // t.Status (string) (string)
13905 case "status":
13906
13907 {
13908 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13909 if err != nil {
13910 return err
13911 }
13912
13913 t.Status = string(sval)
13914 }
13915 // t.CreatedAt (string) (string)
13916 case "createdAt":
13917
13918 {
13919 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13920 if err != nil {
13921 return err
13922 }
13923
13924 t.CreatedAt = string(sval)
13925 }
13926
13927 default:
13928 // Field doesn't exist on this type, so ignore it
13929 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
13930 return err
13931 }
13932 }
13933 }
13934
13935 return nil
13936}
13937func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error {
13938 if t == nil {
13939 _, err := w.Write(cbg.CborNull)
13940 return err
13941 }
13942
13943 cw := cbg.NewCborWriter(w)
13944
13945 if _, err := cw.Write([]byte{162}); err != nil {
13946 return err
13947 }
13948
13949 // t.Repo (string) (string)
13950 if len("repo") > 1000000 {
13951 return xerrors.Errorf("Value in field \"repo\" was too long")
13952 }
13953
13954 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
13955 return err
13956 }
13957 if _, err := cw.WriteString(string("repo")); err != nil {
13958 return err
13959 }
13960
13961 if len(t.Repo) > 1000000 {
13962 return xerrors.Errorf("Value in field t.Repo was too long")
13963 }
13964
13965 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
13966 return err
13967 }
13968 if _, err := cw.WriteString(string(t.Repo)); err != nil {
13969 return err
13970 }
13971
13972 // t.Branch (string) (string)
13973 if len("branch") > 1000000 {
13974 return xerrors.Errorf("Value in field \"branch\" was too long")
13975 }
13976
13977 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
13978 return err
13979 }
13980 if _, err := cw.WriteString(string("branch")); err != nil {
13981 return err
13982 }
13983
13984 if len(t.Branch) > 1000000 {
13985 return xerrors.Errorf("Value in field t.Branch was too long")
13986 }
13987
13988 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
13989 return err
13990 }
13991 if _, err := cw.WriteString(string(t.Branch)); err != nil {
13992 return err
13993 }
13994 return nil
13995}
13996
13997func (t *RepoPull_Target) UnmarshalCBOR(r io.Reader) (err error) {
13998 *t = RepoPull_Target{}
13999
14000 cr := cbg.NewCborReader(r)
14001
14002 maj, extra, err := cr.ReadHeader()
14003 if err != nil {
14004 return err
14005 }
14006 defer func() {
14007 if err == io.EOF {
14008 err = io.ErrUnexpectedEOF
14009 }
14010 }()
14011
14012 if maj != cbg.MajMap {
14013 return fmt.Errorf("cbor input should be of type map")
14014 }
14015
14016 if extra > cbg.MaxLength {
14017 return fmt.Errorf("RepoPull_Target: map struct too large (%d)", extra)
14018 }
14019
14020 n := extra
14021
14022 nameBuf := make([]byte, 6)
14023 for i := uint64(0); i < n; i++ {
14024 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
14025 if err != nil {
14026 return err
14027 }
14028
14029 if !ok {
14030 // Field doesn't exist on this type, so ignore it
14031 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
14032 return err
14033 }
14034 continue
14035 }
14036
14037 switch string(nameBuf[:nameLen]) {
14038 // t.Repo (string) (string)
14039 case "repo":
14040
14041 {
14042 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14043 if err != nil {
14044 return err
14045 }
14046
14047 t.Repo = string(sval)
14048 }
14049 // t.Branch (string) (string)
14050 case "branch":
14051
14052 {
14053 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14054 if err != nil {
14055 return err
14056 }
14057
14058 t.Branch = string(sval)
14059 }
14060
14061 default:
14062 // Field doesn't exist on this type, so ignore it
14063 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
14064 return err
14065 }
14066 }
14067 }
14068
14069 return nil
14070}
14071func (t *Spindle) MarshalCBOR(w io.Writer) error {
14072 if t == nil {
14073 _, err := w.Write(cbg.CborNull)
14074 return err
14075 }
14076
14077 cw := cbg.NewCborWriter(w)
14078
14079 if _, err := cw.Write([]byte{162}); err != nil {
14080 return err
14081 }
14082
14083 // t.LexiconTypeID (string) (string)
14084 if len("$type") > 1000000 {
14085 return xerrors.Errorf("Value in field \"$type\" was too long")
14086 }
14087
14088 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
14089 return err
14090 }
14091 if _, err := cw.WriteString(string("$type")); err != nil {
14092 return err
14093 }
14094
14095 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle"))); err != nil {
14096 return err
14097 }
14098 if _, err := cw.WriteString(string("sh.tangled.spindle")); err != nil {
14099 return err
14100 }
14101
14102 // t.CreatedAt (string) (string)
14103 if len("createdAt") > 1000000 {
14104 return xerrors.Errorf("Value in field \"createdAt\" was too long")
14105 }
14106
14107 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
14108 return err
14109 }
14110 if _, err := cw.WriteString(string("createdAt")); err != nil {
14111 return err
14112 }
14113
14114 if len(t.CreatedAt) > 1000000 {
14115 return xerrors.Errorf("Value in field t.CreatedAt was too long")
14116 }
14117
14118 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
14119 return err
14120 }
14121 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
14122 return err
14123 }
14124 return nil
14125}
14126
14127func (t *Spindle) UnmarshalCBOR(r io.Reader) (err error) {
14128 *t = Spindle{}
14129
14130 cr := cbg.NewCborReader(r)
14131
14132 maj, extra, err := cr.ReadHeader()
14133 if err != nil {
14134 return err
14135 }
14136 defer func() {
14137 if err == io.EOF {
14138 err = io.ErrUnexpectedEOF
14139 }
14140 }()
14141
14142 if maj != cbg.MajMap {
14143 return fmt.Errorf("cbor input should be of type map")
14144 }
14145
14146 if extra > cbg.MaxLength {
14147 return fmt.Errorf("Spindle: map struct too large (%d)", extra)
14148 }
14149
14150 n := extra
14151
14152 nameBuf := make([]byte, 9)
14153 for i := uint64(0); i < n; i++ {
14154 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
14155 if err != nil {
14156 return err
14157 }
14158
14159 if !ok {
14160 // Field doesn't exist on this type, so ignore it
14161 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
14162 return err
14163 }
14164 continue
14165 }
14166
14167 switch string(nameBuf[:nameLen]) {
14168 // t.LexiconTypeID (string) (string)
14169 case "$type":
14170
14171 {
14172 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14173 if err != nil {
14174 return err
14175 }
14176
14177 t.LexiconTypeID = string(sval)
14178 }
14179 // t.CreatedAt (string) (string)
14180 case "createdAt":
14181
14182 {
14183 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14184 if err != nil {
14185 return err
14186 }
14187
14188 t.CreatedAt = string(sval)
14189 }
14190
14191 default:
14192 // Field doesn't exist on this type, so ignore it
14193 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
14194 return err
14195 }
14196 }
14197 }
14198
14199 return nil
14200}
14201func (t *SpindleMember) MarshalCBOR(w io.Writer) error {
14202 if t == nil {
14203 _, err := w.Write(cbg.CborNull)
14204 return err
14205 }
14206
14207 cw := cbg.NewCborWriter(w)
14208
14209 if _, err := cw.Write([]byte{164}); err != nil {
14210 return err
14211 }
14212
14213 // t.LexiconTypeID (string) (string)
14214 if len("$type") > 1000000 {
14215 return xerrors.Errorf("Value in field \"$type\" was too long")
14216 }
14217
14218 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
14219 return err
14220 }
14221 if _, err := cw.WriteString(string("$type")); err != nil {
14222 return err
14223 }
14224
14225 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle.member"))); err != nil {
14226 return err
14227 }
14228 if _, err := cw.WriteString(string("sh.tangled.spindle.member")); err != nil {
14229 return err
14230 }
14231
14232 // t.Subject (string) (string)
14233 if len("subject") > 1000000 {
14234 return xerrors.Errorf("Value in field \"subject\" was too long")
14235 }
14236
14237 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
14238 return err
14239 }
14240 if _, err := cw.WriteString(string("subject")); err != nil {
14241 return err
14242 }
14243
14244 if len(t.Subject) > 1000000 {
14245 return xerrors.Errorf("Value in field t.Subject was too long")
14246 }
14247
14248 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
14249 return err
14250 }
14251 if _, err := cw.WriteString(string(t.Subject)); err != nil {
14252 return err
14253 }
14254
14255 // t.Instance (string) (string)
14256 if len("instance") > 1000000 {
14257 return xerrors.Errorf("Value in field \"instance\" was too long")
14258 }
14259
14260 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("instance"))); err != nil {
14261 return err
14262 }
14263 if _, err := cw.WriteString(string("instance")); err != nil {
14264 return err
14265 }
14266
14267 if len(t.Instance) > 1000000 {
14268 return xerrors.Errorf("Value in field t.Instance was too long")
14269 }
14270
14271 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Instance))); err != nil {
14272 return err
14273 }
14274 if _, err := cw.WriteString(string(t.Instance)); err != nil {
14275 return err
14276 }
14277
14278 // t.CreatedAt (string) (string)
14279 if len("createdAt") > 1000000 {
14280 return xerrors.Errorf("Value in field \"createdAt\" was too long")
14281 }
14282
14283 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
14284 return err
14285 }
14286 if _, err := cw.WriteString(string("createdAt")); err != nil {
14287 return err
14288 }
14289
14290 if len(t.CreatedAt) > 1000000 {
14291 return xerrors.Errorf("Value in field t.CreatedAt was too long")
14292 }
14293
14294 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
14295 return err
14296 }
14297 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
14298 return err
14299 }
14300 return nil
14301}
14302
14303func (t *SpindleMember) UnmarshalCBOR(r io.Reader) (err error) {
14304 *t = SpindleMember{}
14305
14306 cr := cbg.NewCborReader(r)
14307
14308 maj, extra, err := cr.ReadHeader()
14309 if err != nil {
14310 return err
14311 }
14312 defer func() {
14313 if err == io.EOF {
14314 err = io.ErrUnexpectedEOF
14315 }
14316 }()
14317
14318 if maj != cbg.MajMap {
14319 return fmt.Errorf("cbor input should be of type map")
14320 }
14321
14322 if extra > cbg.MaxLength {
14323 return fmt.Errorf("SpindleMember: map struct too large (%d)", extra)
14324 }
14325
14326 n := extra
14327
14328 nameBuf := make([]byte, 9)
14329 for i := uint64(0); i < n; i++ {
14330 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
14331 if err != nil {
14332 return err
14333 }
14334
14335 if !ok {
14336 // Field doesn't exist on this type, so ignore it
14337 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
14338 return err
14339 }
14340 continue
14341 }
14342
14343 switch string(nameBuf[:nameLen]) {
14344 // t.LexiconTypeID (string) (string)
14345 case "$type":
14346
14347 {
14348 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14349 if err != nil {
14350 return err
14351 }
14352
14353 t.LexiconTypeID = string(sval)
14354 }
14355 // t.Subject (string) (string)
14356 case "subject":
14357
14358 {
14359 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14360 if err != nil {
14361 return err
14362 }
14363
14364 t.Subject = string(sval)
14365 }
14366 // t.Instance (string) (string)
14367 case "instance":
14368
14369 {
14370 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14371 if err != nil {
14372 return err
14373 }
14374
14375 t.Instance = string(sval)
14376 }
14377 // t.CreatedAt (string) (string)
14378 case "createdAt":
14379
14380 {
14381 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14382 if err != nil {
14383 return err
14384 }
14385
14386 t.CreatedAt = string(sval)
14387 }
14388
14389 default:
14390 // Field doesn't exist on this type, so ignore it
14391 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
14392 return err
14393 }
14394 }
14395 }
14396
14397 return nil
14398}
14399func (t *String) MarshalCBOR(w io.Writer) error {
14400 if t == nil {
14401 _, err := w.Write(cbg.CborNull)
14402 return err
14403 }
14404
14405 cw := cbg.NewCborWriter(w)
14406
14407 if _, err := cw.Write([]byte{165}); err != nil {
14408 return err
14409 }
14410
14411 // t.LexiconTypeID (string) (string)
14412 if len("$type") > 1000000 {
14413 return xerrors.Errorf("Value in field \"$type\" was too long")
14414 }
14415
14416 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
14417 return err
14418 }
14419 if _, err := cw.WriteString(string("$type")); err != nil {
14420 return err
14421 }
14422
14423 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.string"))); err != nil {
14424 return err
14425 }
14426 if _, err := cw.WriteString(string("sh.tangled.string")); err != nil {
14427 return err
14428 }
14429
14430 // t.Contents (string) (string)
14431 if len("contents") > 1000000 {
14432 return xerrors.Errorf("Value in field \"contents\" was too long")
14433 }
14434
14435 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("contents"))); err != nil {
14436 return err
14437 }
14438 if _, err := cw.WriteString(string("contents")); err != nil {
14439 return err
14440 }
14441
14442 if len(t.Contents) > 1000000 {
14443 return xerrors.Errorf("Value in field t.Contents was too long")
14444 }
14445
14446 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Contents))); err != nil {
14447 return err
14448 }
14449 if _, err := cw.WriteString(string(t.Contents)); err != nil {
14450 return err
14451 }
14452
14453 // t.Filename (string) (string)
14454 if len("filename") > 1000000 {
14455 return xerrors.Errorf("Value in field \"filename\" was too long")
14456 }
14457
14458 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("filename"))); err != nil {
14459 return err
14460 }
14461 if _, err := cw.WriteString(string("filename")); err != nil {
14462 return err
14463 }
14464
14465 if len(t.Filename) > 1000000 {
14466 return xerrors.Errorf("Value in field t.Filename was too long")
14467 }
14468
14469 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Filename))); err != nil {
14470 return err
14471 }
14472 if _, err := cw.WriteString(string(t.Filename)); err != nil {
14473 return err
14474 }
14475
14476 // t.CreatedAt (string) (string)
14477 if len("createdAt") > 1000000 {
14478 return xerrors.Errorf("Value in field \"createdAt\" was too long")
14479 }
14480
14481 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
14482 return err
14483 }
14484 if _, err := cw.WriteString(string("createdAt")); err != nil {
14485 return err
14486 }
14487
14488 if len(t.CreatedAt) > 1000000 {
14489 return xerrors.Errorf("Value in field t.CreatedAt was too long")
14490 }
14491
14492 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
14493 return err
14494 }
14495 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
14496 return err
14497 }
14498
14499 // t.Description (string) (string)
14500 if len("description") > 1000000 {
14501 return xerrors.Errorf("Value in field \"description\" was too long")
14502 }
14503
14504 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
14505 return err
14506 }
14507 if _, err := cw.WriteString(string("description")); err != nil {
14508 return err
14509 }
14510
14511 if len(t.Description) > 1000000 {
14512 return xerrors.Errorf("Value in field t.Description was too long")
14513 }
14514
14515 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil {
14516 return err
14517 }
14518 if _, err := cw.WriteString(string(t.Description)); err != nil {
14519 return err
14520 }
14521 return nil
14522}
14523
14524func (t *String) UnmarshalCBOR(r io.Reader) (err error) {
14525 *t = String{}
14526
14527 cr := cbg.NewCborReader(r)
14528
14529 maj, extra, err := cr.ReadHeader()
14530 if err != nil {
14531 return err
14532 }
14533 defer func() {
14534 if err == io.EOF {
14535 err = io.ErrUnexpectedEOF
14536 }
14537 }()
14538
14539 if maj != cbg.MajMap {
14540 return fmt.Errorf("cbor input should be of type map")
14541 }
14542
14543 if extra > cbg.MaxLength {
14544 return fmt.Errorf("String: map struct too large (%d)", extra)
14545 }
14546
14547 n := extra
14548
14549 nameBuf := make([]byte, 11)
14550 for i := uint64(0); i < n; i++ {
14551 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
14552 if err != nil {
14553 return err
14554 }
14555
14556 if !ok {
14557 // Field doesn't exist on this type, so ignore it
14558 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
14559 return err
14560 }
14561 continue
14562 }
14563
14564 switch string(nameBuf[:nameLen]) {
14565 // t.LexiconTypeID (string) (string)
14566 case "$type":
14567
14568 {
14569 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14570 if err != nil {
14571 return err
14572 }
14573
14574 t.LexiconTypeID = string(sval)
14575 }
14576 // t.Contents (string) (string)
14577 case "contents":
14578
14579 {
14580 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14581 if err != nil {
14582 return err
14583 }
14584
14585 t.Contents = string(sval)
14586 }
14587 // t.Filename (string) (string)
14588 case "filename":
14589
14590 {
14591 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14592 if err != nil {
14593 return err
14594 }
14595
14596 t.Filename = string(sval)
14597 }
14598 // t.CreatedAt (string) (string)
14599 case "createdAt":
14600
14601 {
14602 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14603 if err != nil {
14604 return err
14605 }
14606
14607 t.CreatedAt = string(sval)
14608 }
14609 // t.Description (string) (string)
14610 case "description":
14611
14612 {
14613 sval, err := cbg.ReadStringWithMax(cr, 1000000)
14614 if err != nil {
14615 return err
14616 }
14617
14618 t.Description = string(sval)
14619 }
14620
14621 default:
14622 // Field doesn't exist on this type, so ignore it
14623 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
14624 return err
14625 }
14626 }
14627 }
14628
14629 return nil
14630}