Monorepo for Tangled
tangled.org
1// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
2
3package tangled
4
5import (
6 "fmt"
7 "io"
8 "math"
9 "sort"
10
11 atproto "github.com/bluesky-social/indigo/api/atproto"
12 util "github.com/bluesky-social/indigo/lex/util"
13 cid "github.com/ipfs/go-cid"
14 cbg "github.com/whyrusleeping/cbor-gen"
15 xerrors "golang.org/x/xerrors"
16)
17
18var _ = xerrors.Errorf
19var _ = cid.Undef
20var _ = math.E
21var _ = sort.Sort
22
23func (t *ActorProfile) MarshalCBOR(w io.Writer) error {
24 if t == nil {
25 _, err := w.Write(cbg.CborNull)
26 return err
27 }
28
29 cw := cbg.NewCborWriter(w)
30 fieldCount := 10
31
32 if t.Avatar == nil {
33 fieldCount--
34 }
35
36 if t.Description == nil {
37 fieldCount--
38 }
39
40 if t.Links == nil {
41 fieldCount--
42 }
43
44 if t.Location == nil {
45 fieldCount--
46 }
47
48 if t.PinnedRepositories == nil {
49 fieldCount--
50 }
51
52 if t.PreferredHandle == nil {
53 fieldCount--
54 }
55
56 if t.Pronouns == nil {
57 fieldCount--
58 }
59
60 if t.Stats == nil {
61 fieldCount--
62 }
63
64 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
65 return err
66 }
67
68 // t.LexiconTypeID (string) (string)
69 if len("$type") > 1000000 {
70 return xerrors.Errorf("Value in field \"$type\" was too long")
71 }
72
73 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
74 return err
75 }
76 if _, err := cw.WriteString(string("$type")); err != nil {
77 return err
78 }
79
80 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.actor.profile"))); err != nil {
81 return err
82 }
83 if _, err := cw.WriteString(string("sh.tangled.actor.profile")); err != nil {
84 return err
85 }
86
87 // t.Links ([]string) (slice)
88 if t.Links != nil {
89
90 if len("links") > 1000000 {
91 return xerrors.Errorf("Value in field \"links\" was too long")
92 }
93
94 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("links"))); err != nil {
95 return err
96 }
97 if _, err := cw.WriteString(string("links")); err != nil {
98 return err
99 }
100
101 if len(t.Links) > 8192 {
102 return xerrors.Errorf("Slice value in field t.Links was too long")
103 }
104
105 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Links))); err != nil {
106 return err
107 }
108 for _, v := range t.Links {
109 if len(v) > 1000000 {
110 return xerrors.Errorf("Value in field v was too long")
111 }
112
113 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
114 return err
115 }
116 if _, err := cw.WriteString(string(v)); err != nil {
117 return err
118 }
119
120 }
121 }
122
123 // t.Stats ([]string) (slice)
124 if t.Stats != nil {
125
126 if len("stats") > 1000000 {
127 return xerrors.Errorf("Value in field \"stats\" was too long")
128 }
129
130 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("stats"))); err != nil {
131 return err
132 }
133 if _, err := cw.WriteString(string("stats")); err != nil {
134 return err
135 }
136
137 if len(t.Stats) > 8192 {
138 return xerrors.Errorf("Slice value in field t.Stats was too long")
139 }
140
141 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Stats))); err != nil {
142 return err
143 }
144 for _, v := range t.Stats {
145 if len(v) > 1000000 {
146 return xerrors.Errorf("Value in field v was too long")
147 }
148
149 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
150 return err
151 }
152 if _, err := cw.WriteString(string(v)); err != nil {
153 return err
154 }
155
156 }
157 }
158
159 // t.Avatar (util.LexBlob) (struct)
160 if t.Avatar != nil {
161
162 if len("avatar") > 1000000 {
163 return xerrors.Errorf("Value in field \"avatar\" was too long")
164 }
165
166 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("avatar"))); err != nil {
167 return err
168 }
169 if _, err := cw.WriteString(string("avatar")); err != nil {
170 return err
171 }
172
173 if err := t.Avatar.MarshalCBOR(cw); err != nil {
174 return err
175 }
176 }
177
178 // t.Bluesky (bool) (bool)
179 if len("bluesky") > 1000000 {
180 return xerrors.Errorf("Value in field \"bluesky\" was too long")
181 }
182
183 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("bluesky"))); err != nil {
184 return err
185 }
186 if _, err := cw.WriteString(string("bluesky")); err != nil {
187 return err
188 }
189
190 if err := cbg.WriteBool(w, t.Bluesky); err != nil {
191 return err
192 }
193
194 // t.Location (string) (string)
195 if t.Location != nil {
196
197 if len("location") > 1000000 {
198 return xerrors.Errorf("Value in field \"location\" was too long")
199 }
200
201 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("location"))); err != nil {
202 return err
203 }
204 if _, err := cw.WriteString(string("location")); err != nil {
205 return err
206 }
207
208 if t.Location == nil {
209 if _, err := cw.Write(cbg.CborNull); err != nil {
210 return err
211 }
212 } else {
213 if len(*t.Location) > 1000000 {
214 return xerrors.Errorf("Value in field t.Location was too long")
215 }
216
217 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Location))); err != nil {
218 return err
219 }
220 if _, err := cw.WriteString(string(*t.Location)); err != nil {
221 return err
222 }
223 }
224 }
225
226 // t.Pronouns (string) (string)
227 if t.Pronouns != nil {
228
229 if len("pronouns") > 1000000 {
230 return xerrors.Errorf("Value in field \"pronouns\" was too long")
231 }
232
233 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pronouns"))); err != nil {
234 return err
235 }
236 if _, err := cw.WriteString(string("pronouns")); err != nil {
237 return err
238 }
239
240 if t.Pronouns == nil {
241 if _, err := cw.Write(cbg.CborNull); err != nil {
242 return err
243 }
244 } else {
245 if len(*t.Pronouns) > 1000000 {
246 return xerrors.Errorf("Value in field t.Pronouns was too long")
247 }
248
249 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Pronouns))); err != nil {
250 return err
251 }
252 if _, err := cw.WriteString(string(*t.Pronouns)); err != nil {
253 return err
254 }
255 }
256 }
257
258 // t.Description (string) (string)
259 if t.Description != nil {
260
261 if len("description") > 1000000 {
262 return xerrors.Errorf("Value in field \"description\" was too long")
263 }
264
265 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
266 return err
267 }
268 if _, err := cw.WriteString(string("description")); err != nil {
269 return err
270 }
271
272 if t.Description == nil {
273 if _, err := cw.Write(cbg.CborNull); err != nil {
274 return err
275 }
276 } else {
277 if len(*t.Description) > 1000000 {
278 return xerrors.Errorf("Value in field t.Description was too long")
279 }
280
281 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
282 return err
283 }
284 if _, err := cw.WriteString(string(*t.Description)); err != nil {
285 return err
286 }
287 }
288 }
289
290 // t.PreferredHandle (string) (string)
291 if t.PreferredHandle != nil {
292
293 if len("preferredHandle") > 1000000 {
294 return xerrors.Errorf("Value in field \"preferredHandle\" was too long")
295 }
296
297 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("preferredHandle"))); err != nil {
298 return err
299 }
300 if _, err := cw.WriteString(string("preferredHandle")); err != nil {
301 return err
302 }
303
304 if t.PreferredHandle == nil {
305 if _, err := cw.Write(cbg.CborNull); err != nil {
306 return err
307 }
308 } else {
309 if len(*t.PreferredHandle) > 1000000 {
310 return xerrors.Errorf("Value in field t.PreferredHandle was too long")
311 }
312
313 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.PreferredHandle))); err != nil {
314 return err
315 }
316 if _, err := cw.WriteString(string(*t.PreferredHandle)); err != nil {
317 return err
318 }
319 }
320 }
321
322 // t.PinnedRepositories ([]string) (slice)
323 if t.PinnedRepositories != nil {
324
325 if len("pinnedRepositories") > 1000000 {
326 return xerrors.Errorf("Value in field \"pinnedRepositories\" was too long")
327 }
328
329 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pinnedRepositories"))); err != nil {
330 return err
331 }
332 if _, err := cw.WriteString(string("pinnedRepositories")); err != nil {
333 return err
334 }
335
336 if len(t.PinnedRepositories) > 8192 {
337 return xerrors.Errorf("Slice value in field t.PinnedRepositories was too long")
338 }
339
340 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.PinnedRepositories))); err != nil {
341 return err
342 }
343 for _, v := range t.PinnedRepositories {
344 if len(v) > 1000000 {
345 return xerrors.Errorf("Value in field v was too long")
346 }
347
348 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
349 return err
350 }
351 if _, err := cw.WriteString(string(v)); err != nil {
352 return err
353 }
354
355 }
356 }
357 return nil
358}
359
360func (t *ActorProfile) UnmarshalCBOR(r io.Reader) (err error) {
361 *t = ActorProfile{}
362
363 cr := cbg.NewCborReader(r)
364
365 maj, extra, err := cr.ReadHeader()
366 if err != nil {
367 return err
368 }
369 defer func() {
370 if err == io.EOF {
371 err = io.ErrUnexpectedEOF
372 }
373 }()
374
375 if maj != cbg.MajMap {
376 return fmt.Errorf("cbor input should be of type map")
377 }
378
379 if extra > cbg.MaxLength {
380 return fmt.Errorf("ActorProfile: map struct too large (%d)", extra)
381 }
382
383 n := extra
384
385 nameBuf := make([]byte, 18)
386 for i := uint64(0); i < n; i++ {
387 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
388 if err != nil {
389 return err
390 }
391
392 if !ok {
393 // Field doesn't exist on this type, so ignore it
394 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
395 return err
396 }
397 continue
398 }
399
400 switch string(nameBuf[:nameLen]) {
401 // t.LexiconTypeID (string) (string)
402 case "$type":
403
404 {
405 sval, err := cbg.ReadStringWithMax(cr, 1000000)
406 if err != nil {
407 return err
408 }
409
410 t.LexiconTypeID = string(sval)
411 }
412 // t.Links ([]string) (slice)
413 case "links":
414
415 maj, extra, err = cr.ReadHeader()
416 if err != nil {
417 return err
418 }
419
420 if extra > 8192 {
421 return fmt.Errorf("t.Links: array too large (%d)", extra)
422 }
423
424 if maj != cbg.MajArray {
425 return fmt.Errorf("expected cbor array")
426 }
427
428 if extra > 0 {
429 t.Links = make([]string, extra)
430 }
431
432 for i := 0; i < int(extra); i++ {
433 {
434 var maj byte
435 var extra uint64
436 var err error
437 _ = maj
438 _ = extra
439 _ = err
440
441 {
442 sval, err := cbg.ReadStringWithMax(cr, 1000000)
443 if err != nil {
444 return err
445 }
446
447 t.Links[i] = string(sval)
448 }
449
450 }
451 }
452 // t.Stats ([]string) (slice)
453 case "stats":
454
455 maj, extra, err = cr.ReadHeader()
456 if err != nil {
457 return err
458 }
459
460 if extra > 8192 {
461 return fmt.Errorf("t.Stats: array too large (%d)", extra)
462 }
463
464 if maj != cbg.MajArray {
465 return fmt.Errorf("expected cbor array")
466 }
467
468 if extra > 0 {
469 t.Stats = make([]string, extra)
470 }
471
472 for i := 0; i < int(extra); i++ {
473 {
474 var maj byte
475 var extra uint64
476 var err error
477 _ = maj
478 _ = extra
479 _ = err
480
481 {
482 sval, err := cbg.ReadStringWithMax(cr, 1000000)
483 if err != nil {
484 return err
485 }
486
487 t.Stats[i] = string(sval)
488 }
489
490 }
491 }
492 // t.Avatar (util.LexBlob) (struct)
493 case "avatar":
494
495 {
496
497 b, err := cr.ReadByte()
498 if err != nil {
499 return err
500 }
501 if b != cbg.CborNull[0] {
502 if err := cr.UnreadByte(); err != nil {
503 return err
504 }
505 t.Avatar = new(util.LexBlob)
506 if err := t.Avatar.UnmarshalCBOR(cr); err != nil {
507 return xerrors.Errorf("unmarshaling t.Avatar pointer: %w", err)
508 }
509 }
510
511 }
512 // t.Bluesky (bool) (bool)
513 case "bluesky":
514
515 maj, extra, err = cr.ReadHeader()
516 if err != nil {
517 return err
518 }
519 if maj != cbg.MajOther {
520 return fmt.Errorf("booleans must be major type 7")
521 }
522 switch extra {
523 case 20:
524 t.Bluesky = false
525 case 21:
526 t.Bluesky = true
527 default:
528 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
529 }
530 // t.Location (string) (string)
531 case "location":
532
533 {
534 b, err := cr.ReadByte()
535 if err != nil {
536 return err
537 }
538 if b != cbg.CborNull[0] {
539 if err := cr.UnreadByte(); err != nil {
540 return err
541 }
542
543 sval, err := cbg.ReadStringWithMax(cr, 1000000)
544 if err != nil {
545 return err
546 }
547
548 t.Location = (*string)(&sval)
549 }
550 }
551 // t.Pronouns (string) (string)
552 case "pronouns":
553
554 {
555 b, err := cr.ReadByte()
556 if err != nil {
557 return err
558 }
559 if b != cbg.CborNull[0] {
560 if err := cr.UnreadByte(); err != nil {
561 return err
562 }
563
564 sval, err := cbg.ReadStringWithMax(cr, 1000000)
565 if err != nil {
566 return err
567 }
568
569 t.Pronouns = (*string)(&sval)
570 }
571 }
572 // t.Description (string) (string)
573 case "description":
574
575 {
576 b, err := cr.ReadByte()
577 if err != nil {
578 return err
579 }
580 if b != cbg.CborNull[0] {
581 if err := cr.UnreadByte(); err != nil {
582 return err
583 }
584
585 sval, err := cbg.ReadStringWithMax(cr, 1000000)
586 if err != nil {
587 return err
588 }
589
590 t.Description = (*string)(&sval)
591 }
592 }
593 // t.PreferredHandle (string) (string)
594 case "preferredHandle":
595
596 {
597 b, err := cr.ReadByte()
598 if err != nil {
599 return err
600 }
601 if b != cbg.CborNull[0] {
602 if err := cr.UnreadByte(); err != nil {
603 return err
604 }
605
606 sval, err := cbg.ReadStringWithMax(cr, 1000000)
607 if err != nil {
608 return err
609 }
610
611 t.PreferredHandle = (*string)(&sval)
612 }
613 }
614 // t.PinnedRepositories ([]string) (slice)
615 case "pinnedRepositories":
616
617 maj, extra, err = cr.ReadHeader()
618 if err != nil {
619 return err
620 }
621
622 if extra > 8192 {
623 return fmt.Errorf("t.PinnedRepositories: array too large (%d)", extra)
624 }
625
626 if maj != cbg.MajArray {
627 return fmt.Errorf("expected cbor array")
628 }
629
630 if extra > 0 {
631 t.PinnedRepositories = make([]string, extra)
632 }
633
634 for i := 0; i < int(extra); i++ {
635 {
636 var maj byte
637 var extra uint64
638 var err error
639 _ = maj
640 _ = extra
641 _ = err
642
643 {
644 sval, err := cbg.ReadStringWithMax(cr, 1000000)
645 if err != nil {
646 return err
647 }
648
649 t.PinnedRepositories[i] = string(sval)
650 }
651
652 }
653 }
654
655 default:
656 // Field doesn't exist on this type, so ignore it
657 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
658 return err
659 }
660 }
661 }
662
663 return nil
664}
665func (t *CiDefs_Pipeline) 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 := 6
673
674 if t.CreatedAt == nil {
675 fieldCount--
676 }
677
678 if t.Repo == nil {
679 fieldCount--
680 }
681
682 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
683 return err
684 }
685
686 // t.Id (string) (string)
687 if len("id") > 1000000 {
688 return xerrors.Errorf("Value in field \"id\" was too long")
689 }
690
691 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("id"))); err != nil {
692 return err
693 }
694 if _, err := cw.WriteString(string("id")); err != nil {
695 return err
696 }
697
698 if len(t.Id) > 1000000 {
699 return xerrors.Errorf("Value in field t.Id was too long")
700 }
701
702 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Id))); err != nil {
703 return err
704 }
705 if _, err := cw.WriteString(string(t.Id)); err != nil {
706 return err
707 }
708
709 // t.Repo (string) (string)
710 if t.Repo != nil {
711
712 if len("repo") > 1000000 {
713 return xerrors.Errorf("Value in field \"repo\" was too long")
714 }
715
716 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
717 return err
718 }
719 if _, err := cw.WriteString(string("repo")); err != nil {
720 return err
721 }
722
723 if t.Repo == nil {
724 if _, err := cw.Write(cbg.CborNull); err != nil {
725 return err
726 }
727 } else {
728 if len(*t.Repo) > 1000000 {
729 return xerrors.Errorf("Value in field t.Repo was too long")
730 }
731
732 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
733 return err
734 }
735 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
736 return err
737 }
738 }
739 }
740
741 // t.Commit (string) (string)
742 if len("commit") > 1000000 {
743 return xerrors.Errorf("Value in field \"commit\" was too long")
744 }
745
746 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commit"))); err != nil {
747 return err
748 }
749 if _, err := cw.WriteString(string("commit")); err != nil {
750 return err
751 }
752
753 if len(t.Commit) > 1000000 {
754 return xerrors.Errorf("Value in field t.Commit was too long")
755 }
756
757 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Commit))); err != nil {
758 return err
759 }
760 if _, err := cw.WriteString(string(t.Commit)); err != nil {
761 return err
762 }
763
764 // t.Trigger (tangled.CiDefs_Pipeline_Trigger) (struct)
765 if len("trigger") > 1000000 {
766 return xerrors.Errorf("Value in field \"trigger\" was too long")
767 }
768
769 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("trigger"))); err != nil {
770 return err
771 }
772 if _, err := cw.WriteString(string("trigger")); err != nil {
773 return err
774 }
775
776 if err := t.Trigger.MarshalCBOR(cw); err != nil {
777 return err
778 }
779
780 // t.CreatedAt (string) (string)
781 if t.CreatedAt != nil {
782
783 if len("createdAt") > 1000000 {
784 return xerrors.Errorf("Value in field \"createdAt\" was too long")
785 }
786
787 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
788 return err
789 }
790 if _, err := cw.WriteString(string("createdAt")); err != nil {
791 return err
792 }
793
794 if t.CreatedAt == nil {
795 if _, err := cw.Write(cbg.CborNull); err != nil {
796 return err
797 }
798 } else {
799 if len(*t.CreatedAt) > 1000000 {
800 return xerrors.Errorf("Value in field t.CreatedAt was too long")
801 }
802
803 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.CreatedAt))); err != nil {
804 return err
805 }
806 if _, err := cw.WriteString(string(*t.CreatedAt)); err != nil {
807 return err
808 }
809 }
810 }
811
812 // t.Workflows ([]*tangled.CiDefs_Workflow) (slice)
813 if len("workflows") > 1000000 {
814 return xerrors.Errorf("Value in field \"workflows\" was too long")
815 }
816
817 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil {
818 return err
819 }
820 if _, err := cw.WriteString(string("workflows")); err != nil {
821 return err
822 }
823
824 if len(t.Workflows) > 8192 {
825 return xerrors.Errorf("Slice value in field t.Workflows was too long")
826 }
827
828 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil {
829 return err
830 }
831 for _, v := range t.Workflows {
832 if err := v.MarshalCBOR(cw); err != nil {
833 return err
834 }
835
836 }
837 return nil
838}
839
840func (t *CiDefs_Pipeline) UnmarshalCBOR(r io.Reader) (err error) {
841 *t = CiDefs_Pipeline{}
842
843 cr := cbg.NewCborReader(r)
844
845 maj, extra, err := cr.ReadHeader()
846 if err != nil {
847 return err
848 }
849 defer func() {
850 if err == io.EOF {
851 err = io.ErrUnexpectedEOF
852 }
853 }()
854
855 if maj != cbg.MajMap {
856 return fmt.Errorf("cbor input should be of type map")
857 }
858
859 if extra > cbg.MaxLength {
860 return fmt.Errorf("CiDefs_Pipeline: map struct too large (%d)", extra)
861 }
862
863 n := extra
864
865 nameBuf := make([]byte, 9)
866 for i := uint64(0); i < n; i++ {
867 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
868 if err != nil {
869 return err
870 }
871
872 if !ok {
873 // Field doesn't exist on this type, so ignore it
874 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
875 return err
876 }
877 continue
878 }
879
880 switch string(nameBuf[:nameLen]) {
881 // t.Id (string) (string)
882 case "id":
883
884 {
885 sval, err := cbg.ReadStringWithMax(cr, 1000000)
886 if err != nil {
887 return err
888 }
889
890 t.Id = string(sval)
891 }
892 // t.Repo (string) (string)
893 case "repo":
894
895 {
896 b, err := cr.ReadByte()
897 if err != nil {
898 return err
899 }
900 if b != cbg.CborNull[0] {
901 if err := cr.UnreadByte(); err != nil {
902 return err
903 }
904
905 sval, err := cbg.ReadStringWithMax(cr, 1000000)
906 if err != nil {
907 return err
908 }
909
910 t.Repo = (*string)(&sval)
911 }
912 }
913 // t.Commit (string) (string)
914 case "commit":
915
916 {
917 sval, err := cbg.ReadStringWithMax(cr, 1000000)
918 if err != nil {
919 return err
920 }
921
922 t.Commit = string(sval)
923 }
924 // t.Trigger (tangled.CiDefs_Pipeline_Trigger) (struct)
925 case "trigger":
926
927 {
928
929 b, err := cr.ReadByte()
930 if err != nil {
931 return err
932 }
933 if b != cbg.CborNull[0] {
934 if err := cr.UnreadByte(); err != nil {
935 return err
936 }
937 t.Trigger = new(CiDefs_Pipeline_Trigger)
938 if err := t.Trigger.UnmarshalCBOR(cr); err != nil {
939 return xerrors.Errorf("unmarshaling t.Trigger pointer: %w", err)
940 }
941 }
942
943 }
944 // t.CreatedAt (string) (string)
945 case "createdAt":
946
947 {
948 b, err := cr.ReadByte()
949 if err != nil {
950 return err
951 }
952 if b != cbg.CborNull[0] {
953 if err := cr.UnreadByte(); err != nil {
954 return err
955 }
956
957 sval, err := cbg.ReadStringWithMax(cr, 1000000)
958 if err != nil {
959 return err
960 }
961
962 t.CreatedAt = (*string)(&sval)
963 }
964 }
965 // t.Workflows ([]*tangled.CiDefs_Workflow) (slice)
966 case "workflows":
967
968 maj, extra, err = cr.ReadHeader()
969 if err != nil {
970 return err
971 }
972
973 if extra > 8192 {
974 return fmt.Errorf("t.Workflows: array too large (%d)", extra)
975 }
976
977 if maj != cbg.MajArray {
978 return fmt.Errorf("expected cbor array")
979 }
980
981 if extra > 0 {
982 t.Workflows = make([]*CiDefs_Workflow, extra)
983 }
984
985 for i := 0; i < int(extra); i++ {
986 {
987 var maj byte
988 var extra uint64
989 var err error
990 _ = maj
991 _ = extra
992 _ = err
993
994 {
995
996 b, err := cr.ReadByte()
997 if err != nil {
998 return err
999 }
1000 if b != cbg.CborNull[0] {
1001 if err := cr.UnreadByte(); err != nil {
1002 return err
1003 }
1004 t.Workflows[i] = new(CiDefs_Workflow)
1005 if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil {
1006 return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err)
1007 }
1008 }
1009
1010 }
1011
1012 }
1013 }
1014
1015 default:
1016 // Field doesn't exist on this type, so ignore it
1017 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1018 return err
1019 }
1020 }
1021 }
1022
1023 return nil
1024}
1025func (t *CiDefs_Pipeline_Trigger) MarshalCBOR(w io.Writer) error {
1026 if t == nil {
1027 _, err := w.Write(cbg.CborNull)
1028 return err
1029 }
1030
1031 cw := cbg.NewCborWriter(w)
1032
1033 if _, err := cw.Write([]byte{163}); err != nil {
1034 return err
1035 }
1036
1037 // t.CiTrigger_Push (tangled.CiTrigger_Push) (struct)
1038 if len("CiTrigger_Push") > 1000000 {
1039 return xerrors.Errorf("Value in field \"CiTrigger_Push\" was too long")
1040 }
1041
1042 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("CiTrigger_Push"))); err != nil {
1043 return err
1044 }
1045 if _, err := cw.WriteString(string("CiTrigger_Push")); err != nil {
1046 return err
1047 }
1048
1049 if err := t.CiTrigger_Push.MarshalCBOR(cw); err != nil {
1050 return err
1051 }
1052
1053 // t.CiTrigger_Manual (tangled.CiTrigger_Manual) (struct)
1054 if len("CiTrigger_Manual") > 1000000 {
1055 return xerrors.Errorf("Value in field \"CiTrigger_Manual\" was too long")
1056 }
1057
1058 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("CiTrigger_Manual"))); err != nil {
1059 return err
1060 }
1061 if _, err := cw.WriteString(string("CiTrigger_Manual")); err != nil {
1062 return err
1063 }
1064
1065 if err := t.CiTrigger_Manual.MarshalCBOR(cw); err != nil {
1066 return err
1067 }
1068
1069 // t.CiTrigger_PullRequest (tangled.CiTrigger_PullRequest) (struct)
1070 if len("CiTrigger_PullRequest") > 1000000 {
1071 return xerrors.Errorf("Value in field \"CiTrigger_PullRequest\" was too long")
1072 }
1073
1074 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("CiTrigger_PullRequest"))); err != nil {
1075 return err
1076 }
1077 if _, err := cw.WriteString(string("CiTrigger_PullRequest")); err != nil {
1078 return err
1079 }
1080
1081 if err := t.CiTrigger_PullRequest.MarshalCBOR(cw); err != nil {
1082 return err
1083 }
1084 return nil
1085}
1086
1087func (t *CiDefs_Pipeline_Trigger) UnmarshalCBOR(r io.Reader) (err error) {
1088 *t = CiDefs_Pipeline_Trigger{}
1089
1090 cr := cbg.NewCborReader(r)
1091
1092 maj, extra, err := cr.ReadHeader()
1093 if err != nil {
1094 return err
1095 }
1096 defer func() {
1097 if err == io.EOF {
1098 err = io.ErrUnexpectedEOF
1099 }
1100 }()
1101
1102 if maj != cbg.MajMap {
1103 return fmt.Errorf("cbor input should be of type map")
1104 }
1105
1106 if extra > cbg.MaxLength {
1107 return fmt.Errorf("CiDefs_Pipeline_Trigger: map struct too large (%d)", extra)
1108 }
1109
1110 n := extra
1111
1112 nameBuf := make([]byte, 21)
1113 for i := uint64(0); i < n; i++ {
1114 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1115 if err != nil {
1116 return err
1117 }
1118
1119 if !ok {
1120 // Field doesn't exist on this type, so ignore it
1121 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1122 return err
1123 }
1124 continue
1125 }
1126
1127 switch string(nameBuf[:nameLen]) {
1128 // t.CiTrigger_Push (tangled.CiTrigger_Push) (struct)
1129 case "CiTrigger_Push":
1130
1131 {
1132
1133 b, err := cr.ReadByte()
1134 if err != nil {
1135 return err
1136 }
1137 if b != cbg.CborNull[0] {
1138 if err := cr.UnreadByte(); err != nil {
1139 return err
1140 }
1141 t.CiTrigger_Push = new(CiTrigger_Push)
1142 if err := t.CiTrigger_Push.UnmarshalCBOR(cr); err != nil {
1143 return xerrors.Errorf("unmarshaling t.CiTrigger_Push pointer: %w", err)
1144 }
1145 }
1146
1147 }
1148 // t.CiTrigger_Manual (tangled.CiTrigger_Manual) (struct)
1149 case "CiTrigger_Manual":
1150
1151 {
1152
1153 b, err := cr.ReadByte()
1154 if err != nil {
1155 return err
1156 }
1157 if b != cbg.CborNull[0] {
1158 if err := cr.UnreadByte(); err != nil {
1159 return err
1160 }
1161 t.CiTrigger_Manual = new(CiTrigger_Manual)
1162 if err := t.CiTrigger_Manual.UnmarshalCBOR(cr); err != nil {
1163 return xerrors.Errorf("unmarshaling t.CiTrigger_Manual pointer: %w", err)
1164 }
1165 }
1166
1167 }
1168 // t.CiTrigger_PullRequest (tangled.CiTrigger_PullRequest) (struct)
1169 case "CiTrigger_PullRequest":
1170
1171 {
1172
1173 b, err := cr.ReadByte()
1174 if err != nil {
1175 return err
1176 }
1177 if b != cbg.CborNull[0] {
1178 if err := cr.UnreadByte(); err != nil {
1179 return err
1180 }
1181 t.CiTrigger_PullRequest = new(CiTrigger_PullRequest)
1182 if err := t.CiTrigger_PullRequest.UnmarshalCBOR(cr); err != nil {
1183 return xerrors.Errorf("unmarshaling t.CiTrigger_PullRequest pointer: %w", err)
1184 }
1185 }
1186
1187 }
1188
1189 default:
1190 // Field doesn't exist on this type, so ignore it
1191 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1192 return err
1193 }
1194 }
1195 }
1196
1197 return nil
1198}
1199func (t *CiDefs_Workflow) MarshalCBOR(w io.Writer) error {
1200 if t == nil {
1201 _, err := w.Write(cbg.CborNull)
1202 return err
1203 }
1204
1205 cw := cbg.NewCborWriter(w)
1206 fieldCount := 5
1207
1208 if t.FinishedAt == nil {
1209 fieldCount--
1210 }
1211
1212 if t.StartedAt == nil {
1213 fieldCount--
1214 }
1215
1216 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1217 return err
1218 }
1219
1220 // t.Id (int64) (int64)
1221 if len("id") > 1000000 {
1222 return xerrors.Errorf("Value in field \"id\" was too long")
1223 }
1224
1225 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("id"))); err != nil {
1226 return err
1227 }
1228 if _, err := cw.WriteString(string("id")); err != nil {
1229 return err
1230 }
1231
1232 if t.Id >= 0 {
1233 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Id)); err != nil {
1234 return err
1235 }
1236 } else {
1237 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Id-1)); err != nil {
1238 return err
1239 }
1240 }
1241
1242 // t.Name (string) (string)
1243 if len("name") > 1000000 {
1244 return xerrors.Errorf("Value in field \"name\" was too long")
1245 }
1246
1247 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
1248 return err
1249 }
1250 if _, err := cw.WriteString(string("name")); err != nil {
1251 return err
1252 }
1253
1254 if len(t.Name) > 1000000 {
1255 return xerrors.Errorf("Value in field t.Name was too long")
1256 }
1257
1258 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
1259 return err
1260 }
1261 if _, err := cw.WriteString(string(t.Name)); err != nil {
1262 return err
1263 }
1264
1265 // t.Status (string) (string)
1266 if len("status") > 1000000 {
1267 return xerrors.Errorf("Value in field \"status\" was too long")
1268 }
1269
1270 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
1271 return err
1272 }
1273 if _, err := cw.WriteString(string("status")); err != nil {
1274 return err
1275 }
1276
1277 if len(t.Status) > 1000000 {
1278 return xerrors.Errorf("Value in field t.Status was too long")
1279 }
1280
1281 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
1282 return err
1283 }
1284 if _, err := cw.WriteString(string(t.Status)); err != nil {
1285 return err
1286 }
1287
1288 // t.StartedAt (string) (string)
1289 if t.StartedAt != nil {
1290
1291 if len("startedAt") > 1000000 {
1292 return xerrors.Errorf("Value in field \"startedAt\" was too long")
1293 }
1294
1295 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("startedAt"))); err != nil {
1296 return err
1297 }
1298 if _, err := cw.WriteString(string("startedAt")); err != nil {
1299 return err
1300 }
1301
1302 if t.StartedAt == nil {
1303 if _, err := cw.Write(cbg.CborNull); err != nil {
1304 return err
1305 }
1306 } else {
1307 if len(*t.StartedAt) > 1000000 {
1308 return xerrors.Errorf("Value in field t.StartedAt was too long")
1309 }
1310
1311 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.StartedAt))); err != nil {
1312 return err
1313 }
1314 if _, err := cw.WriteString(string(*t.StartedAt)); err != nil {
1315 return err
1316 }
1317 }
1318 }
1319
1320 // t.FinishedAt (string) (string)
1321 if t.FinishedAt != nil {
1322
1323 if len("finishedAt") > 1000000 {
1324 return xerrors.Errorf("Value in field \"finishedAt\" was too long")
1325 }
1326
1327 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("finishedAt"))); err != nil {
1328 return err
1329 }
1330 if _, err := cw.WriteString(string("finishedAt")); err != nil {
1331 return err
1332 }
1333
1334 if t.FinishedAt == nil {
1335 if _, err := cw.Write(cbg.CborNull); err != nil {
1336 return err
1337 }
1338 } else {
1339 if len(*t.FinishedAt) > 1000000 {
1340 return xerrors.Errorf("Value in field t.FinishedAt was too long")
1341 }
1342
1343 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.FinishedAt))); err != nil {
1344 return err
1345 }
1346 if _, err := cw.WriteString(string(*t.FinishedAt)); err != nil {
1347 return err
1348 }
1349 }
1350 }
1351 return nil
1352}
1353
1354func (t *CiDefs_Workflow) UnmarshalCBOR(r io.Reader) (err error) {
1355 *t = CiDefs_Workflow{}
1356
1357 cr := cbg.NewCborReader(r)
1358
1359 maj, extra, err := cr.ReadHeader()
1360 if err != nil {
1361 return err
1362 }
1363 defer func() {
1364 if err == io.EOF {
1365 err = io.ErrUnexpectedEOF
1366 }
1367 }()
1368
1369 if maj != cbg.MajMap {
1370 return fmt.Errorf("cbor input should be of type map")
1371 }
1372
1373 if extra > cbg.MaxLength {
1374 return fmt.Errorf("CiDefs_Workflow: map struct too large (%d)", extra)
1375 }
1376
1377 n := extra
1378
1379 nameBuf := make([]byte, 10)
1380 for i := uint64(0); i < n; i++ {
1381 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1382 if err != nil {
1383 return err
1384 }
1385
1386 if !ok {
1387 // Field doesn't exist on this type, so ignore it
1388 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1389 return err
1390 }
1391 continue
1392 }
1393
1394 switch string(nameBuf[:nameLen]) {
1395 // t.Id (int64) (int64)
1396 case "id":
1397 {
1398 maj, extra, err := cr.ReadHeader()
1399 if err != nil {
1400 return err
1401 }
1402 var extraI int64
1403 switch maj {
1404 case cbg.MajUnsignedInt:
1405 extraI = int64(extra)
1406 if extraI < 0 {
1407 return fmt.Errorf("int64 positive overflow")
1408 }
1409 case cbg.MajNegativeInt:
1410 extraI = int64(extra)
1411 if extraI < 0 {
1412 return fmt.Errorf("int64 negative overflow")
1413 }
1414 extraI = -1 - extraI
1415 default:
1416 return fmt.Errorf("wrong type for int64 field: %d", maj)
1417 }
1418
1419 t.Id = int64(extraI)
1420 }
1421 // t.Name (string) (string)
1422 case "name":
1423
1424 {
1425 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1426 if err != nil {
1427 return err
1428 }
1429
1430 t.Name = string(sval)
1431 }
1432 // t.Status (string) (string)
1433 case "status":
1434
1435 {
1436 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1437 if err != nil {
1438 return err
1439 }
1440
1441 t.Status = string(sval)
1442 }
1443 // t.StartedAt (string) (string)
1444 case "startedAt":
1445
1446 {
1447 b, err := cr.ReadByte()
1448 if err != nil {
1449 return err
1450 }
1451 if b != cbg.CborNull[0] {
1452 if err := cr.UnreadByte(); err != nil {
1453 return err
1454 }
1455
1456 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1457 if err != nil {
1458 return err
1459 }
1460
1461 t.StartedAt = (*string)(&sval)
1462 }
1463 }
1464 // t.FinishedAt (string) (string)
1465 case "finishedAt":
1466
1467 {
1468 b, err := cr.ReadByte()
1469 if err != nil {
1470 return err
1471 }
1472 if b != cbg.CborNull[0] {
1473 if err := cr.UnreadByte(); err != nil {
1474 return err
1475 }
1476
1477 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1478 if err != nil {
1479 return err
1480 }
1481
1482 t.FinishedAt = (*string)(&sval)
1483 }
1484 }
1485
1486 default:
1487 // Field doesn't exist on this type, so ignore it
1488 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1489 return err
1490 }
1491 }
1492 }
1493
1494 return nil
1495}
1496func (t *CiPipelineSubscribeLogs_Control) MarshalCBOR(w io.Writer) error {
1497 if t == nil {
1498 _, err := w.Write(cbg.CborNull)
1499 return err
1500 }
1501
1502 cw := cbg.NewCborWriter(w)
1503 fieldCount := 7
1504
1505 if t.Command == nil {
1506 fieldCount--
1507 }
1508
1509 if t.Kind == nil {
1510 fieldCount--
1511 }
1512
1513 if t.Status == nil {
1514 fieldCount--
1515 }
1516
1517 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1518 return err
1519 }
1520
1521 // t.Kind (string) (string)
1522 if t.Kind != nil {
1523
1524 if len("kind") > 1000000 {
1525 return xerrors.Errorf("Value in field \"kind\" was too long")
1526 }
1527
1528 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("kind"))); err != nil {
1529 return err
1530 }
1531 if _, err := cw.WriteString(string("kind")); err != nil {
1532 return err
1533 }
1534
1535 if t.Kind == nil {
1536 if _, err := cw.Write(cbg.CborNull); err != nil {
1537 return err
1538 }
1539 } else {
1540 if len(*t.Kind) > 1000000 {
1541 return xerrors.Errorf("Value in field t.Kind was too long")
1542 }
1543
1544 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Kind))); err != nil {
1545 return err
1546 }
1547 if _, err := cw.WriteString(string(*t.Kind)); err != nil {
1548 return err
1549 }
1550 }
1551 }
1552
1553 // t.Step (int64) (int64)
1554 if len("step") > 1000000 {
1555 return xerrors.Errorf("Value in field \"step\" was too long")
1556 }
1557
1558 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("step"))); err != nil {
1559 return err
1560 }
1561 if _, err := cw.WriteString(string("step")); err != nil {
1562 return err
1563 }
1564
1565 if t.Step >= 0 {
1566 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Step)); err != nil {
1567 return err
1568 }
1569 } else {
1570 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Step-1)); err != nil {
1571 return err
1572 }
1573 }
1574
1575 // t.Time (string) (string)
1576 if len("time") > 1000000 {
1577 return xerrors.Errorf("Value in field \"time\" was too long")
1578 }
1579
1580 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("time"))); err != nil {
1581 return err
1582 }
1583 if _, err := cw.WriteString(string("time")); err != nil {
1584 return err
1585 }
1586
1587 if len(t.Time) > 1000000 {
1588 return xerrors.Errorf("Value in field t.Time was too long")
1589 }
1590
1591 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Time))); err != nil {
1592 return err
1593 }
1594 if _, err := cw.WriteString(string(t.Time)); err != nil {
1595 return err
1596 }
1597
1598 // t.Status (string) (string)
1599 if t.Status != nil {
1600
1601 if len("status") > 1000000 {
1602 return xerrors.Errorf("Value in field \"status\" was too long")
1603 }
1604
1605 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
1606 return err
1607 }
1608 if _, err := cw.WriteString(string("status")); err != nil {
1609 return err
1610 }
1611
1612 if t.Status == nil {
1613 if _, err := cw.Write(cbg.CborNull); err != nil {
1614 return err
1615 }
1616 } else {
1617 if len(*t.Status) > 1000000 {
1618 return xerrors.Errorf("Value in field t.Status was too long")
1619 }
1620
1621 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Status))); err != nil {
1622 return err
1623 }
1624 if _, err := cw.WriteString(string(*t.Status)); err != nil {
1625 return err
1626 }
1627 }
1628 }
1629
1630 // t.Command (string) (string)
1631 if t.Command != nil {
1632
1633 if len("command") > 1000000 {
1634 return xerrors.Errorf("Value in field \"command\" was too long")
1635 }
1636
1637 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("command"))); err != nil {
1638 return err
1639 }
1640 if _, err := cw.WriteString(string("command")); err != nil {
1641 return err
1642 }
1643
1644 if t.Command == nil {
1645 if _, err := cw.Write(cbg.CborNull); err != nil {
1646 return err
1647 }
1648 } else {
1649 if len(*t.Command) > 1000000 {
1650 return xerrors.Errorf("Value in field t.Command was too long")
1651 }
1652
1653 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Command))); err != nil {
1654 return err
1655 }
1656 if _, err := cw.WriteString(string(*t.Command)); err != nil {
1657 return err
1658 }
1659 }
1660 }
1661
1662 // t.Content (string) (string)
1663 if len("content") > 1000000 {
1664 return xerrors.Errorf("Value in field \"content\" was too long")
1665 }
1666
1667 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("content"))); err != nil {
1668 return err
1669 }
1670 if _, err := cw.WriteString(string("content")); err != nil {
1671 return err
1672 }
1673
1674 if len(t.Content) > 1000000 {
1675 return xerrors.Errorf("Value in field t.Content was too long")
1676 }
1677
1678 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Content))); err != nil {
1679 return err
1680 }
1681 if _, err := cw.WriteString(string(t.Content)); err != nil {
1682 return err
1683 }
1684
1685 // t.Workflow (string) (string)
1686 if len("workflow") > 1000000 {
1687 return xerrors.Errorf("Value in field \"workflow\" was too long")
1688 }
1689
1690 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil {
1691 return err
1692 }
1693 if _, err := cw.WriteString(string("workflow")); err != nil {
1694 return err
1695 }
1696
1697 if len(t.Workflow) > 1000000 {
1698 return xerrors.Errorf("Value in field t.Workflow was too long")
1699 }
1700
1701 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil {
1702 return err
1703 }
1704 if _, err := cw.WriteString(string(t.Workflow)); err != nil {
1705 return err
1706 }
1707 return nil
1708}
1709
1710func (t *CiPipelineSubscribeLogs_Control) UnmarshalCBOR(r io.Reader) (err error) {
1711 *t = CiPipelineSubscribeLogs_Control{}
1712
1713 cr := cbg.NewCborReader(r)
1714
1715 maj, extra, err := cr.ReadHeader()
1716 if err != nil {
1717 return err
1718 }
1719 defer func() {
1720 if err == io.EOF {
1721 err = io.ErrUnexpectedEOF
1722 }
1723 }()
1724
1725 if maj != cbg.MajMap {
1726 return fmt.Errorf("cbor input should be of type map")
1727 }
1728
1729 if extra > cbg.MaxLength {
1730 return fmt.Errorf("CiPipelineSubscribeLogs_Control: map struct too large (%d)", extra)
1731 }
1732
1733 n := extra
1734
1735 nameBuf := make([]byte, 8)
1736 for i := uint64(0); i < n; i++ {
1737 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1738 if err != nil {
1739 return err
1740 }
1741
1742 if !ok {
1743 // Field doesn't exist on this type, so ignore it
1744 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1745 return err
1746 }
1747 continue
1748 }
1749
1750 switch string(nameBuf[:nameLen]) {
1751 // t.Kind (string) (string)
1752 case "kind":
1753
1754 {
1755 b, err := cr.ReadByte()
1756 if err != nil {
1757 return err
1758 }
1759 if b != cbg.CborNull[0] {
1760 if err := cr.UnreadByte(); err != nil {
1761 return err
1762 }
1763
1764 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1765 if err != nil {
1766 return err
1767 }
1768
1769 t.Kind = (*string)(&sval)
1770 }
1771 }
1772 // t.Step (int64) (int64)
1773 case "step":
1774 {
1775 maj, extra, err := cr.ReadHeader()
1776 if err != nil {
1777 return err
1778 }
1779 var extraI int64
1780 switch maj {
1781 case cbg.MajUnsignedInt:
1782 extraI = int64(extra)
1783 if extraI < 0 {
1784 return fmt.Errorf("int64 positive overflow")
1785 }
1786 case cbg.MajNegativeInt:
1787 extraI = int64(extra)
1788 if extraI < 0 {
1789 return fmt.Errorf("int64 negative overflow")
1790 }
1791 extraI = -1 - extraI
1792 default:
1793 return fmt.Errorf("wrong type for int64 field: %d", maj)
1794 }
1795
1796 t.Step = int64(extraI)
1797 }
1798 // t.Time (string) (string)
1799 case "time":
1800
1801 {
1802 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1803 if err != nil {
1804 return err
1805 }
1806
1807 t.Time = string(sval)
1808 }
1809 // t.Status (string) (string)
1810 case "status":
1811
1812 {
1813 b, err := cr.ReadByte()
1814 if err != nil {
1815 return err
1816 }
1817 if b != cbg.CborNull[0] {
1818 if err := cr.UnreadByte(); err != nil {
1819 return err
1820 }
1821
1822 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1823 if err != nil {
1824 return err
1825 }
1826
1827 t.Status = (*string)(&sval)
1828 }
1829 }
1830 // t.Command (string) (string)
1831 case "command":
1832
1833 {
1834 b, err := cr.ReadByte()
1835 if err != nil {
1836 return err
1837 }
1838 if b != cbg.CborNull[0] {
1839 if err := cr.UnreadByte(); err != nil {
1840 return err
1841 }
1842
1843 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1844 if err != nil {
1845 return err
1846 }
1847
1848 t.Command = (*string)(&sval)
1849 }
1850 }
1851 // t.Content (string) (string)
1852 case "content":
1853
1854 {
1855 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1856 if err != nil {
1857 return err
1858 }
1859
1860 t.Content = string(sval)
1861 }
1862 // t.Workflow (string) (string)
1863 case "workflow":
1864
1865 {
1866 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1867 if err != nil {
1868 return err
1869 }
1870
1871 t.Workflow = string(sval)
1872 }
1873
1874 default:
1875 // Field doesn't exist on this type, so ignore it
1876 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1877 return err
1878 }
1879 }
1880 }
1881
1882 return nil
1883}
1884func (t *CiPipelineSubscribeLogs_Data) MarshalCBOR(w io.Writer) error {
1885 if t == nil {
1886 _, err := w.Write(cbg.CborNull)
1887 return err
1888 }
1889
1890 cw := cbg.NewCborWriter(w)
1891
1892 if _, err := cw.Write([]byte{165}); err != nil {
1893 return err
1894 }
1895
1896 // t.Step (int64) (int64)
1897 if len("step") > 1000000 {
1898 return xerrors.Errorf("Value in field \"step\" was too long")
1899 }
1900
1901 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("step"))); err != nil {
1902 return err
1903 }
1904 if _, err := cw.WriteString(string("step")); err != nil {
1905 return err
1906 }
1907
1908 if t.Step >= 0 {
1909 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Step)); err != nil {
1910 return err
1911 }
1912 } else {
1913 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Step-1)); err != nil {
1914 return err
1915 }
1916 }
1917
1918 // t.Time (string) (string)
1919 if len("time") > 1000000 {
1920 return xerrors.Errorf("Value in field \"time\" was too long")
1921 }
1922
1923 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("time"))); err != nil {
1924 return err
1925 }
1926 if _, err := cw.WriteString(string("time")); err != nil {
1927 return err
1928 }
1929
1930 if len(t.Time) > 1000000 {
1931 return xerrors.Errorf("Value in field t.Time was too long")
1932 }
1933
1934 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Time))); err != nil {
1935 return err
1936 }
1937 if _, err := cw.WriteString(string(t.Time)); err != nil {
1938 return err
1939 }
1940
1941 // t.Stream (string) (string)
1942 if len("stream") > 1000000 {
1943 return xerrors.Errorf("Value in field \"stream\" was too long")
1944 }
1945
1946 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("stream"))); err != nil {
1947 return err
1948 }
1949 if _, err := cw.WriteString(string("stream")); err != nil {
1950 return err
1951 }
1952
1953 if len(t.Stream) > 1000000 {
1954 return xerrors.Errorf("Value in field t.Stream was too long")
1955 }
1956
1957 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Stream))); err != nil {
1958 return err
1959 }
1960 if _, err := cw.WriteString(string(t.Stream)); err != nil {
1961 return err
1962 }
1963
1964 // t.Content (string) (string)
1965 if len("content") > 1000000 {
1966 return xerrors.Errorf("Value in field \"content\" was too long")
1967 }
1968
1969 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("content"))); err != nil {
1970 return err
1971 }
1972 if _, err := cw.WriteString(string("content")); err != nil {
1973 return err
1974 }
1975
1976 if len(t.Content) > 1000000 {
1977 return xerrors.Errorf("Value in field t.Content was too long")
1978 }
1979
1980 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Content))); err != nil {
1981 return err
1982 }
1983 if _, err := cw.WriteString(string(t.Content)); err != nil {
1984 return err
1985 }
1986
1987 // t.Workflow (string) (string)
1988 if len("workflow") > 1000000 {
1989 return xerrors.Errorf("Value in field \"workflow\" was too long")
1990 }
1991
1992 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil {
1993 return err
1994 }
1995 if _, err := cw.WriteString(string("workflow")); err != nil {
1996 return err
1997 }
1998
1999 if len(t.Workflow) > 1000000 {
2000 return xerrors.Errorf("Value in field t.Workflow was too long")
2001 }
2002
2003 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil {
2004 return err
2005 }
2006 if _, err := cw.WriteString(string(t.Workflow)); err != nil {
2007 return err
2008 }
2009 return nil
2010}
2011
2012func (t *CiPipelineSubscribeLogs_Data) UnmarshalCBOR(r io.Reader) (err error) {
2013 *t = CiPipelineSubscribeLogs_Data{}
2014
2015 cr := cbg.NewCborReader(r)
2016
2017 maj, extra, err := cr.ReadHeader()
2018 if err != nil {
2019 return err
2020 }
2021 defer func() {
2022 if err == io.EOF {
2023 err = io.ErrUnexpectedEOF
2024 }
2025 }()
2026
2027 if maj != cbg.MajMap {
2028 return fmt.Errorf("cbor input should be of type map")
2029 }
2030
2031 if extra > cbg.MaxLength {
2032 return fmt.Errorf("CiPipelineSubscribeLogs_Data: map struct too large (%d)", extra)
2033 }
2034
2035 n := extra
2036
2037 nameBuf := make([]byte, 8)
2038 for i := uint64(0); i < n; i++ {
2039 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2040 if err != nil {
2041 return err
2042 }
2043
2044 if !ok {
2045 // Field doesn't exist on this type, so ignore it
2046 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2047 return err
2048 }
2049 continue
2050 }
2051
2052 switch string(nameBuf[:nameLen]) {
2053 // t.Step (int64) (int64)
2054 case "step":
2055 {
2056 maj, extra, err := cr.ReadHeader()
2057 if err != nil {
2058 return err
2059 }
2060 var extraI int64
2061 switch maj {
2062 case cbg.MajUnsignedInt:
2063 extraI = int64(extra)
2064 if extraI < 0 {
2065 return fmt.Errorf("int64 positive overflow")
2066 }
2067 case cbg.MajNegativeInt:
2068 extraI = int64(extra)
2069 if extraI < 0 {
2070 return fmt.Errorf("int64 negative overflow")
2071 }
2072 extraI = -1 - extraI
2073 default:
2074 return fmt.Errorf("wrong type for int64 field: %d", maj)
2075 }
2076
2077 t.Step = int64(extraI)
2078 }
2079 // t.Time (string) (string)
2080 case "time":
2081
2082 {
2083 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2084 if err != nil {
2085 return err
2086 }
2087
2088 t.Time = string(sval)
2089 }
2090 // t.Stream (string) (string)
2091 case "stream":
2092
2093 {
2094 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2095 if err != nil {
2096 return err
2097 }
2098
2099 t.Stream = string(sval)
2100 }
2101 // t.Content (string) (string)
2102 case "content":
2103
2104 {
2105 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2106 if err != nil {
2107 return err
2108 }
2109
2110 t.Content = string(sval)
2111 }
2112 // t.Workflow (string) (string)
2113 case "workflow":
2114
2115 {
2116 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2117 if err != nil {
2118 return err
2119 }
2120
2121 t.Workflow = string(sval)
2122 }
2123
2124 default:
2125 // Field doesn't exist on this type, so ignore it
2126 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2127 return err
2128 }
2129 }
2130 }
2131
2132 return nil
2133}
2134func (t *CiTrigger_Manual) MarshalCBOR(w io.Writer) error {
2135 if t == nil {
2136 _, err := w.Write(cbg.CborNull)
2137 return err
2138 }
2139
2140 cw := cbg.NewCborWriter(w)
2141
2142 if _, err := cw.Write([]byte{161}); err != nil {
2143 return err
2144 }
2145
2146 // t.LexiconTypeID (string) (string)
2147 if len("$type") > 1000000 {
2148 return xerrors.Errorf("Value in field \"$type\" was too long")
2149 }
2150
2151 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2152 return err
2153 }
2154 if _, err := cw.WriteString(string("$type")); err != nil {
2155 return err
2156 }
2157
2158 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.ci.trigger#manual"))); err != nil {
2159 return err
2160 }
2161 if _, err := cw.WriteString(string("sh.tangled.ci.trigger#manual")); err != nil {
2162 return err
2163 }
2164 return nil
2165}
2166
2167func (t *CiTrigger_Manual) UnmarshalCBOR(r io.Reader) (err error) {
2168 *t = CiTrigger_Manual{}
2169
2170 cr := cbg.NewCborReader(r)
2171
2172 maj, extra, err := cr.ReadHeader()
2173 if err != nil {
2174 return err
2175 }
2176 defer func() {
2177 if err == io.EOF {
2178 err = io.ErrUnexpectedEOF
2179 }
2180 }()
2181
2182 if maj != cbg.MajMap {
2183 return fmt.Errorf("cbor input should be of type map")
2184 }
2185
2186 if extra > cbg.MaxLength {
2187 return fmt.Errorf("CiTrigger_Manual: map struct too large (%d)", extra)
2188 }
2189
2190 n := extra
2191
2192 nameBuf := make([]byte, 5)
2193 for i := uint64(0); i < n; i++ {
2194 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2195 if err != nil {
2196 return err
2197 }
2198
2199 if !ok {
2200 // Field doesn't exist on this type, so ignore it
2201 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2202 return err
2203 }
2204 continue
2205 }
2206
2207 switch string(nameBuf[:nameLen]) {
2208 // t.LexiconTypeID (string) (string)
2209 case "$type":
2210
2211 {
2212 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2213 if err != nil {
2214 return err
2215 }
2216
2217 t.LexiconTypeID = string(sval)
2218 }
2219
2220 default:
2221 // Field doesn't exist on this type, so ignore it
2222 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2223 return err
2224 }
2225 }
2226 }
2227
2228 return nil
2229}
2230func (t *CiTrigger_PullRequest) MarshalCBOR(w io.Writer) error {
2231 if t == nil {
2232 _, err := w.Write(cbg.CborNull)
2233 return err
2234 }
2235
2236 cw := cbg.NewCborWriter(w)
2237 fieldCount := 5
2238
2239 if t.SourceBranch == nil {
2240 fieldCount--
2241 }
2242
2243 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2244 return err
2245 }
2246
2247 // t.LexiconTypeID (string) (string)
2248 if len("$type") > 1000000 {
2249 return xerrors.Errorf("Value in field \"$type\" was too long")
2250 }
2251
2252 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2253 return err
2254 }
2255 if _, err := cw.WriteString(string("$type")); err != nil {
2256 return err
2257 }
2258
2259 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.ci.trigger#pullRequest"))); err != nil {
2260 return err
2261 }
2262 if _, err := cw.WriteString(string("sh.tangled.ci.trigger#pullRequest")); err != nil {
2263 return err
2264 }
2265
2266 // t.Action (string) (string)
2267 if len("action") > 1000000 {
2268 return xerrors.Errorf("Value in field \"action\" was too long")
2269 }
2270
2271 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("action"))); err != nil {
2272 return err
2273 }
2274 if _, err := cw.WriteString(string("action")); err != nil {
2275 return err
2276 }
2277
2278 if len(t.Action) > 1000000 {
2279 return xerrors.Errorf("Value in field t.Action was too long")
2280 }
2281
2282 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Action))); err != nil {
2283 return err
2284 }
2285 if _, err := cw.WriteString(string(t.Action)); err != nil {
2286 return err
2287 }
2288
2289 // t.SourceSha (string) (string)
2290 if len("sourceSha") > 1000000 {
2291 return xerrors.Errorf("Value in field \"sourceSha\" was too long")
2292 }
2293
2294 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceSha"))); err != nil {
2295 return err
2296 }
2297 if _, err := cw.WriteString(string("sourceSha")); err != nil {
2298 return err
2299 }
2300
2301 if len(t.SourceSha) > 1000000 {
2302 return xerrors.Errorf("Value in field t.SourceSha was too long")
2303 }
2304
2305 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceSha))); err != nil {
2306 return err
2307 }
2308 if _, err := cw.WriteString(string(t.SourceSha)); err != nil {
2309 return err
2310 }
2311
2312 // t.SourceBranch (string) (string)
2313 if t.SourceBranch != nil {
2314
2315 if len("sourceBranch") > 1000000 {
2316 return xerrors.Errorf("Value in field \"sourceBranch\" was too long")
2317 }
2318
2319 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceBranch"))); err != nil {
2320 return err
2321 }
2322 if _, err := cw.WriteString(string("sourceBranch")); err != nil {
2323 return err
2324 }
2325
2326 if t.SourceBranch == nil {
2327 if _, err := cw.Write(cbg.CborNull); err != nil {
2328 return err
2329 }
2330 } else {
2331 if len(*t.SourceBranch) > 1000000 {
2332 return xerrors.Errorf("Value in field t.SourceBranch was too long")
2333 }
2334
2335 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.SourceBranch))); err != nil {
2336 return err
2337 }
2338 if _, err := cw.WriteString(string(*t.SourceBranch)); err != nil {
2339 return err
2340 }
2341 }
2342 }
2343
2344 // t.TargetBranch (string) (string)
2345 if len("targetBranch") > 1000000 {
2346 return xerrors.Errorf("Value in field \"targetBranch\" was too long")
2347 }
2348
2349 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil {
2350 return err
2351 }
2352 if _, err := cw.WriteString(string("targetBranch")); err != nil {
2353 return err
2354 }
2355
2356 if len(t.TargetBranch) > 1000000 {
2357 return xerrors.Errorf("Value in field t.TargetBranch was too long")
2358 }
2359
2360 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil {
2361 return err
2362 }
2363 if _, err := cw.WriteString(string(t.TargetBranch)); err != nil {
2364 return err
2365 }
2366 return nil
2367}
2368
2369func (t *CiTrigger_PullRequest) UnmarshalCBOR(r io.Reader) (err error) {
2370 *t = CiTrigger_PullRequest{}
2371
2372 cr := cbg.NewCborReader(r)
2373
2374 maj, extra, err := cr.ReadHeader()
2375 if err != nil {
2376 return err
2377 }
2378 defer func() {
2379 if err == io.EOF {
2380 err = io.ErrUnexpectedEOF
2381 }
2382 }()
2383
2384 if maj != cbg.MajMap {
2385 return fmt.Errorf("cbor input should be of type map")
2386 }
2387
2388 if extra > cbg.MaxLength {
2389 return fmt.Errorf("CiTrigger_PullRequest: map struct too large (%d)", extra)
2390 }
2391
2392 n := extra
2393
2394 nameBuf := make([]byte, 12)
2395 for i := uint64(0); i < n; i++ {
2396 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2397 if err != nil {
2398 return err
2399 }
2400
2401 if !ok {
2402 // Field doesn't exist on this type, so ignore it
2403 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2404 return err
2405 }
2406 continue
2407 }
2408
2409 switch string(nameBuf[:nameLen]) {
2410 // t.LexiconTypeID (string) (string)
2411 case "$type":
2412
2413 {
2414 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2415 if err != nil {
2416 return err
2417 }
2418
2419 t.LexiconTypeID = string(sval)
2420 }
2421 // t.Action (string) (string)
2422 case "action":
2423
2424 {
2425 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2426 if err != nil {
2427 return err
2428 }
2429
2430 t.Action = string(sval)
2431 }
2432 // t.SourceSha (string) (string)
2433 case "sourceSha":
2434
2435 {
2436 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2437 if err != nil {
2438 return err
2439 }
2440
2441 t.SourceSha = string(sval)
2442 }
2443 // t.SourceBranch (string) (string)
2444 case "sourceBranch":
2445
2446 {
2447 b, err := cr.ReadByte()
2448 if err != nil {
2449 return err
2450 }
2451 if b != cbg.CborNull[0] {
2452 if err := cr.UnreadByte(); err != nil {
2453 return err
2454 }
2455
2456 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2457 if err != nil {
2458 return err
2459 }
2460
2461 t.SourceBranch = (*string)(&sval)
2462 }
2463 }
2464 // t.TargetBranch (string) (string)
2465 case "targetBranch":
2466
2467 {
2468 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2469 if err != nil {
2470 return err
2471 }
2472
2473 t.TargetBranch = string(sval)
2474 }
2475
2476 default:
2477 // Field doesn't exist on this type, so ignore it
2478 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2479 return err
2480 }
2481 }
2482 }
2483
2484 return nil
2485}
2486func (t *CiTrigger_Push) MarshalCBOR(w io.Writer) error {
2487 if t == nil {
2488 _, err := w.Write(cbg.CborNull)
2489 return err
2490 }
2491
2492 cw := cbg.NewCborWriter(w)
2493
2494 if _, err := cw.Write([]byte{164}); err != nil {
2495 return err
2496 }
2497
2498 // t.Ref (string) (string)
2499 if len("ref") > 1000000 {
2500 return xerrors.Errorf("Value in field \"ref\" was too long")
2501 }
2502
2503 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
2504 return err
2505 }
2506 if _, err := cw.WriteString(string("ref")); err != nil {
2507 return err
2508 }
2509
2510 if len(t.Ref) > 1000000 {
2511 return xerrors.Errorf("Value in field t.Ref was too long")
2512 }
2513
2514 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
2515 return err
2516 }
2517 if _, err := cw.WriteString(string(t.Ref)); err != nil {
2518 return err
2519 }
2520
2521 // t.LexiconTypeID (string) (string)
2522 if len("$type") > 1000000 {
2523 return xerrors.Errorf("Value in field \"$type\" was too long")
2524 }
2525
2526 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2527 return err
2528 }
2529 if _, err := cw.WriteString(string("$type")); err != nil {
2530 return err
2531 }
2532
2533 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.ci.trigger#push"))); err != nil {
2534 return err
2535 }
2536 if _, err := cw.WriteString(string("sh.tangled.ci.trigger#push")); err != nil {
2537 return err
2538 }
2539
2540 // t.NewSha (string) (string)
2541 if len("newSha") > 1000000 {
2542 return xerrors.Errorf("Value in field \"newSha\" was too long")
2543 }
2544
2545 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
2546 return err
2547 }
2548 if _, err := cw.WriteString(string("newSha")); err != nil {
2549 return err
2550 }
2551
2552 if len(t.NewSha) > 1000000 {
2553 return xerrors.Errorf("Value in field t.NewSha was too long")
2554 }
2555
2556 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
2557 return err
2558 }
2559 if _, err := cw.WriteString(string(t.NewSha)); err != nil {
2560 return err
2561 }
2562
2563 // t.OldSha (string) (string)
2564 if len("oldSha") > 1000000 {
2565 return xerrors.Errorf("Value in field \"oldSha\" was too long")
2566 }
2567
2568 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
2569 return err
2570 }
2571 if _, err := cw.WriteString(string("oldSha")); err != nil {
2572 return err
2573 }
2574
2575 if len(t.OldSha) > 1000000 {
2576 return xerrors.Errorf("Value in field t.OldSha was too long")
2577 }
2578
2579 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
2580 return err
2581 }
2582 if _, err := cw.WriteString(string(t.OldSha)); err != nil {
2583 return err
2584 }
2585 return nil
2586}
2587
2588func (t *CiTrigger_Push) UnmarshalCBOR(r io.Reader) (err error) {
2589 *t = CiTrigger_Push{}
2590
2591 cr := cbg.NewCborReader(r)
2592
2593 maj, extra, err := cr.ReadHeader()
2594 if err != nil {
2595 return err
2596 }
2597 defer func() {
2598 if err == io.EOF {
2599 err = io.ErrUnexpectedEOF
2600 }
2601 }()
2602
2603 if maj != cbg.MajMap {
2604 return fmt.Errorf("cbor input should be of type map")
2605 }
2606
2607 if extra > cbg.MaxLength {
2608 return fmt.Errorf("CiTrigger_Push: map struct too large (%d)", extra)
2609 }
2610
2611 n := extra
2612
2613 nameBuf := make([]byte, 6)
2614 for i := uint64(0); i < n; i++ {
2615 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2616 if err != nil {
2617 return err
2618 }
2619
2620 if !ok {
2621 // Field doesn't exist on this type, so ignore it
2622 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2623 return err
2624 }
2625 continue
2626 }
2627
2628 switch string(nameBuf[:nameLen]) {
2629 // t.Ref (string) (string)
2630 case "ref":
2631
2632 {
2633 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2634 if err != nil {
2635 return err
2636 }
2637
2638 t.Ref = string(sval)
2639 }
2640 // t.LexiconTypeID (string) (string)
2641 case "$type":
2642
2643 {
2644 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2645 if err != nil {
2646 return err
2647 }
2648
2649 t.LexiconTypeID = string(sval)
2650 }
2651 // t.NewSha (string) (string)
2652 case "newSha":
2653
2654 {
2655 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2656 if err != nil {
2657 return err
2658 }
2659
2660 t.NewSha = string(sval)
2661 }
2662 // t.OldSha (string) (string)
2663 case "oldSha":
2664
2665 {
2666 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2667 if err != nil {
2668 return err
2669 }
2670
2671 t.OldSha = string(sval)
2672 }
2673
2674 default:
2675 // Field doesn't exist on this type, so ignore it
2676 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2677 return err
2678 }
2679 }
2680 }
2681
2682 return nil
2683}
2684func (t *FeedComment) MarshalCBOR(w io.Writer) error {
2685 if t == nil {
2686 _, err := w.Write(cbg.CborNull)
2687 return err
2688 }
2689
2690 cw := cbg.NewCborWriter(w)
2691 fieldCount := 6
2692
2693 if t.PullRoundIdx == nil {
2694 fieldCount--
2695 }
2696
2697 if t.ReplyTo == nil {
2698 fieldCount--
2699 }
2700
2701 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2702 return err
2703 }
2704
2705 // t.Body (tangled.FeedComment_Body) (struct)
2706 if len("body") > 1000000 {
2707 return xerrors.Errorf("Value in field \"body\" was too long")
2708 }
2709
2710 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
2711 return err
2712 }
2713 if _, err := cw.WriteString(string("body")); err != nil {
2714 return err
2715 }
2716
2717 if err := t.Body.MarshalCBOR(cw); err != nil {
2718 return err
2719 }
2720
2721 // t.LexiconTypeID (string) (string)
2722 if len("$type") > 1000000 {
2723 return xerrors.Errorf("Value in field \"$type\" was too long")
2724 }
2725
2726 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2727 return err
2728 }
2729 if _, err := cw.WriteString(string("$type")); err != nil {
2730 return err
2731 }
2732
2733 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.comment"))); err != nil {
2734 return err
2735 }
2736 if _, err := cw.WriteString(string("sh.tangled.feed.comment")); err != nil {
2737 return err
2738 }
2739
2740 // t.ReplyTo (atproto.RepoStrongRef) (struct)
2741 if t.ReplyTo != nil {
2742
2743 if len("replyTo") > 1000000 {
2744 return xerrors.Errorf("Value in field \"replyTo\" was too long")
2745 }
2746
2747 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("replyTo"))); err != nil {
2748 return err
2749 }
2750 if _, err := cw.WriteString(string("replyTo")); err != nil {
2751 return err
2752 }
2753
2754 if err := t.ReplyTo.MarshalCBOR(cw); err != nil {
2755 return err
2756 }
2757 }
2758
2759 // t.Subject (atproto.RepoStrongRef) (struct)
2760 if len("subject") > 1000000 {
2761 return xerrors.Errorf("Value in field \"subject\" was too long")
2762 }
2763
2764 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
2765 return err
2766 }
2767 if _, err := cw.WriteString(string("subject")); err != nil {
2768 return err
2769 }
2770
2771 if err := t.Subject.MarshalCBOR(cw); err != nil {
2772 return err
2773 }
2774
2775 // t.CreatedAt (string) (string)
2776 if len("createdAt") > 1000000 {
2777 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2778 }
2779
2780 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2781 return err
2782 }
2783 if _, err := cw.WriteString(string("createdAt")); err != nil {
2784 return err
2785 }
2786
2787 if len(t.CreatedAt) > 1000000 {
2788 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2789 }
2790
2791 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2792 return err
2793 }
2794 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2795 return err
2796 }
2797
2798 // t.PullRoundIdx (int64) (int64)
2799 if t.PullRoundIdx != nil {
2800
2801 if len("pullRoundIdx") > 1000000 {
2802 return xerrors.Errorf("Value in field \"pullRoundIdx\" was too long")
2803 }
2804
2805 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullRoundIdx"))); err != nil {
2806 return err
2807 }
2808 if _, err := cw.WriteString(string("pullRoundIdx")); err != nil {
2809 return err
2810 }
2811
2812 if t.PullRoundIdx == nil {
2813 if _, err := cw.Write(cbg.CborNull); err != nil {
2814 return err
2815 }
2816 } else {
2817 if *t.PullRoundIdx >= 0 {
2818 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.PullRoundIdx)); err != nil {
2819 return err
2820 }
2821 } else {
2822 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.PullRoundIdx-1)); err != nil {
2823 return err
2824 }
2825 }
2826 }
2827
2828 }
2829 return nil
2830}
2831
2832func (t *FeedComment) UnmarshalCBOR(r io.Reader) (err error) {
2833 *t = FeedComment{}
2834
2835 cr := cbg.NewCborReader(r)
2836
2837 maj, extra, err := cr.ReadHeader()
2838 if err != nil {
2839 return err
2840 }
2841 defer func() {
2842 if err == io.EOF {
2843 err = io.ErrUnexpectedEOF
2844 }
2845 }()
2846
2847 if maj != cbg.MajMap {
2848 return fmt.Errorf("cbor input should be of type map")
2849 }
2850
2851 if extra > cbg.MaxLength {
2852 return fmt.Errorf("FeedComment: map struct too large (%d)", extra)
2853 }
2854
2855 n := extra
2856
2857 nameBuf := make([]byte, 12)
2858 for i := uint64(0); i < n; i++ {
2859 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2860 if err != nil {
2861 return err
2862 }
2863
2864 if !ok {
2865 // Field doesn't exist on this type, so ignore it
2866 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2867 return err
2868 }
2869 continue
2870 }
2871
2872 switch string(nameBuf[:nameLen]) {
2873 // t.Body (tangled.FeedComment_Body) (struct)
2874 case "body":
2875
2876 {
2877
2878 b, err := cr.ReadByte()
2879 if err != nil {
2880 return err
2881 }
2882 if b != cbg.CborNull[0] {
2883 if err := cr.UnreadByte(); err != nil {
2884 return err
2885 }
2886 t.Body = new(FeedComment_Body)
2887 if err := t.Body.UnmarshalCBOR(cr); err != nil {
2888 return xerrors.Errorf("unmarshaling t.Body pointer: %w", err)
2889 }
2890 }
2891
2892 }
2893 // t.LexiconTypeID (string) (string)
2894 case "$type":
2895
2896 {
2897 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2898 if err != nil {
2899 return err
2900 }
2901
2902 t.LexiconTypeID = string(sval)
2903 }
2904 // t.ReplyTo (atproto.RepoStrongRef) (struct)
2905 case "replyTo":
2906
2907 {
2908
2909 b, err := cr.ReadByte()
2910 if err != nil {
2911 return err
2912 }
2913 if b != cbg.CborNull[0] {
2914 if err := cr.UnreadByte(); err != nil {
2915 return err
2916 }
2917 t.ReplyTo = new(atproto.RepoStrongRef)
2918 if err := t.ReplyTo.UnmarshalCBOR(cr); err != nil {
2919 return xerrors.Errorf("unmarshaling t.ReplyTo pointer: %w", err)
2920 }
2921 }
2922
2923 }
2924 // t.Subject (atproto.RepoStrongRef) (struct)
2925 case "subject":
2926
2927 {
2928
2929 b, err := cr.ReadByte()
2930 if err != nil {
2931 return err
2932 }
2933 if b != cbg.CborNull[0] {
2934 if err := cr.UnreadByte(); err != nil {
2935 return err
2936 }
2937 t.Subject = new(atproto.RepoStrongRef)
2938 if err := t.Subject.UnmarshalCBOR(cr); err != nil {
2939 return xerrors.Errorf("unmarshaling t.Subject pointer: %w", err)
2940 }
2941 }
2942
2943 }
2944 // t.CreatedAt (string) (string)
2945 case "createdAt":
2946
2947 {
2948 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2949 if err != nil {
2950 return err
2951 }
2952
2953 t.CreatedAt = string(sval)
2954 }
2955 // t.PullRoundIdx (int64) (int64)
2956 case "pullRoundIdx":
2957 {
2958
2959 b, err := cr.ReadByte()
2960 if err != nil {
2961 return err
2962 }
2963 if b != cbg.CborNull[0] {
2964 if err := cr.UnreadByte(); err != nil {
2965 return err
2966 }
2967 maj, extra, err := cr.ReadHeader()
2968 if err != nil {
2969 return err
2970 }
2971 var extraI int64
2972 switch maj {
2973 case cbg.MajUnsignedInt:
2974 extraI = int64(extra)
2975 if extraI < 0 {
2976 return fmt.Errorf("int64 positive overflow")
2977 }
2978 case cbg.MajNegativeInt:
2979 extraI = int64(extra)
2980 if extraI < 0 {
2981 return fmt.Errorf("int64 negative overflow")
2982 }
2983 extraI = -1 - extraI
2984 default:
2985 return fmt.Errorf("wrong type for int64 field: %d", maj)
2986 }
2987
2988 t.PullRoundIdx = (*int64)(&extraI)
2989 }
2990 }
2991
2992 default:
2993 // Field doesn't exist on this type, so ignore it
2994 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2995 return err
2996 }
2997 }
2998 }
2999
3000 return nil
3001}
3002func (t *FeedReaction) MarshalCBOR(w io.Writer) error {
3003 if t == nil {
3004 _, err := w.Write(cbg.CborNull)
3005 return err
3006 }
3007
3008 cw := cbg.NewCborWriter(w)
3009
3010 if _, err := cw.Write([]byte{164}); err != nil {
3011 return err
3012 }
3013
3014 // t.LexiconTypeID (string) (string)
3015 if len("$type") > 1000000 {
3016 return xerrors.Errorf("Value in field \"$type\" was too long")
3017 }
3018
3019 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3020 return err
3021 }
3022 if _, err := cw.WriteString(string("$type")); err != nil {
3023 return err
3024 }
3025
3026 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.reaction"))); err != nil {
3027 return err
3028 }
3029 if _, err := cw.WriteString(string("sh.tangled.feed.reaction")); err != nil {
3030 return err
3031 }
3032
3033 // t.Subject (string) (string)
3034 if len("subject") > 1000000 {
3035 return xerrors.Errorf("Value in field \"subject\" was too long")
3036 }
3037
3038 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
3039 return err
3040 }
3041 if _, err := cw.WriteString(string("subject")); err != nil {
3042 return err
3043 }
3044
3045 if len(t.Subject) > 1000000 {
3046 return xerrors.Errorf("Value in field t.Subject was too long")
3047 }
3048
3049 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
3050 return err
3051 }
3052 if _, err := cw.WriteString(string(t.Subject)); err != nil {
3053 return err
3054 }
3055
3056 // t.Reaction (string) (string)
3057 if len("reaction") > 1000000 {
3058 return xerrors.Errorf("Value in field \"reaction\" was too long")
3059 }
3060
3061 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("reaction"))); err != nil {
3062 return err
3063 }
3064 if _, err := cw.WriteString(string("reaction")); err != nil {
3065 return err
3066 }
3067
3068 if len(t.Reaction) > 1000000 {
3069 return xerrors.Errorf("Value in field t.Reaction was too long")
3070 }
3071
3072 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Reaction))); err != nil {
3073 return err
3074 }
3075 if _, err := cw.WriteString(string(t.Reaction)); err != nil {
3076 return err
3077 }
3078
3079 // t.CreatedAt (string) (string)
3080 if len("createdAt") > 1000000 {
3081 return xerrors.Errorf("Value in field \"createdAt\" was too long")
3082 }
3083
3084 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
3085 return err
3086 }
3087 if _, err := cw.WriteString(string("createdAt")); err != nil {
3088 return err
3089 }
3090
3091 if len(t.CreatedAt) > 1000000 {
3092 return xerrors.Errorf("Value in field t.CreatedAt was too long")
3093 }
3094
3095 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
3096 return err
3097 }
3098 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
3099 return err
3100 }
3101 return nil
3102}
3103
3104func (t *FeedReaction) UnmarshalCBOR(r io.Reader) (err error) {
3105 *t = FeedReaction{}
3106
3107 cr := cbg.NewCborReader(r)
3108
3109 maj, extra, err := cr.ReadHeader()
3110 if err != nil {
3111 return err
3112 }
3113 defer func() {
3114 if err == io.EOF {
3115 err = io.ErrUnexpectedEOF
3116 }
3117 }()
3118
3119 if maj != cbg.MajMap {
3120 return fmt.Errorf("cbor input should be of type map")
3121 }
3122
3123 if extra > cbg.MaxLength {
3124 return fmt.Errorf("FeedReaction: map struct too large (%d)", extra)
3125 }
3126
3127 n := extra
3128
3129 nameBuf := make([]byte, 9)
3130 for i := uint64(0); i < n; i++ {
3131 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3132 if err != nil {
3133 return err
3134 }
3135
3136 if !ok {
3137 // Field doesn't exist on this type, so ignore it
3138 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3139 return err
3140 }
3141 continue
3142 }
3143
3144 switch string(nameBuf[:nameLen]) {
3145 // t.LexiconTypeID (string) (string)
3146 case "$type":
3147
3148 {
3149 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3150 if err != nil {
3151 return err
3152 }
3153
3154 t.LexiconTypeID = string(sval)
3155 }
3156 // t.Subject (string) (string)
3157 case "subject":
3158
3159 {
3160 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3161 if err != nil {
3162 return err
3163 }
3164
3165 t.Subject = string(sval)
3166 }
3167 // t.Reaction (string) (string)
3168 case "reaction":
3169
3170 {
3171 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3172 if err != nil {
3173 return err
3174 }
3175
3176 t.Reaction = string(sval)
3177 }
3178 // t.CreatedAt (string) (string)
3179 case "createdAt":
3180
3181 {
3182 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3183 if err != nil {
3184 return err
3185 }
3186
3187 t.CreatedAt = string(sval)
3188 }
3189
3190 default:
3191 // Field doesn't exist on this type, so ignore it
3192 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3193 return err
3194 }
3195 }
3196 }
3197
3198 return nil
3199}
3200func (t *FeedStar) MarshalCBOR(w io.Writer) error {
3201 if t == nil {
3202 _, err := w.Write(cbg.CborNull)
3203 return err
3204 }
3205
3206 cw := cbg.NewCborWriter(w)
3207
3208 if _, err := cw.Write([]byte{163}); err != nil {
3209 return err
3210 }
3211
3212 // t.LexiconTypeID (string) (string)
3213 if len("$type") > 1000000 {
3214 return xerrors.Errorf("Value in field \"$type\" was too long")
3215 }
3216
3217 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3218 return err
3219 }
3220 if _, err := cw.WriteString(string("$type")); err != nil {
3221 return err
3222 }
3223
3224 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.star"))); err != nil {
3225 return err
3226 }
3227 if _, err := cw.WriteString(string("sh.tangled.feed.star")); err != nil {
3228 return err
3229 }
3230
3231 // t.Subject (tangled.FeedStar_Subject) (struct)
3232 if len("subject") > 1000000 {
3233 return xerrors.Errorf("Value in field \"subject\" was too long")
3234 }
3235
3236 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
3237 return err
3238 }
3239 if _, err := cw.WriteString(string("subject")); err != nil {
3240 return err
3241 }
3242
3243 if err := t.Subject.MarshalCBOR(cw); err != nil {
3244 return err
3245 }
3246
3247 // t.CreatedAt (string) (string)
3248 if len("createdAt") > 1000000 {
3249 return xerrors.Errorf("Value in field \"createdAt\" was too long")
3250 }
3251
3252 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
3253 return err
3254 }
3255 if _, err := cw.WriteString(string("createdAt")); err != nil {
3256 return err
3257 }
3258
3259 if len(t.CreatedAt) > 1000000 {
3260 return xerrors.Errorf("Value in field t.CreatedAt was too long")
3261 }
3262
3263 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
3264 return err
3265 }
3266 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
3267 return err
3268 }
3269 return nil
3270}
3271
3272func (t *FeedStar) UnmarshalCBOR(r io.Reader) (err error) {
3273 *t = FeedStar{}
3274
3275 cr := cbg.NewCborReader(r)
3276
3277 maj, extra, err := cr.ReadHeader()
3278 if err != nil {
3279 return err
3280 }
3281 defer func() {
3282 if err == io.EOF {
3283 err = io.ErrUnexpectedEOF
3284 }
3285 }()
3286
3287 if maj != cbg.MajMap {
3288 return fmt.Errorf("cbor input should be of type map")
3289 }
3290
3291 if extra > cbg.MaxLength {
3292 return fmt.Errorf("FeedStar: map struct too large (%d)", extra)
3293 }
3294
3295 n := extra
3296
3297 nameBuf := make([]byte, 9)
3298 for i := uint64(0); i < n; i++ {
3299 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3300 if err != nil {
3301 return err
3302 }
3303
3304 if !ok {
3305 // Field doesn't exist on this type, so ignore it
3306 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3307 return err
3308 }
3309 continue
3310 }
3311
3312 switch string(nameBuf[:nameLen]) {
3313 // t.LexiconTypeID (string) (string)
3314 case "$type":
3315
3316 {
3317 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3318 if err != nil {
3319 return err
3320 }
3321
3322 t.LexiconTypeID = string(sval)
3323 }
3324 // t.Subject (tangled.FeedStar_Subject) (struct)
3325 case "subject":
3326
3327 {
3328
3329 b, err := cr.ReadByte()
3330 if err != nil {
3331 return err
3332 }
3333 if b != cbg.CborNull[0] {
3334 if err := cr.UnreadByte(); err != nil {
3335 return err
3336 }
3337 t.Subject = new(FeedStar_Subject)
3338 if err := t.Subject.UnmarshalCBOR(cr); err != nil {
3339 return xerrors.Errorf("unmarshaling t.Subject pointer: %w", err)
3340 }
3341 }
3342
3343 }
3344 // t.CreatedAt (string) (string)
3345 case "createdAt":
3346
3347 {
3348 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3349 if err != nil {
3350 return err
3351 }
3352
3353 t.CreatedAt = string(sval)
3354 }
3355
3356 default:
3357 // Field doesn't exist on this type, so ignore it
3358 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3359 return err
3360 }
3361 }
3362 }
3363
3364 return nil
3365}
3366func (t *FeedStar_Repo) MarshalCBOR(w io.Writer) error {
3367 if t == nil {
3368 _, err := w.Write(cbg.CborNull)
3369 return err
3370 }
3371
3372 cw := cbg.NewCborWriter(w)
3373
3374 if _, err := cw.Write([]byte{162}); err != nil {
3375 return err
3376 }
3377
3378 // t.Did (string) (string)
3379 if len("did") > 1000000 {
3380 return xerrors.Errorf("Value in field \"did\" was too long")
3381 }
3382
3383 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil {
3384 return err
3385 }
3386 if _, err := cw.WriteString(string("did")); err != nil {
3387 return err
3388 }
3389
3390 if len(t.Did) > 1000000 {
3391 return xerrors.Errorf("Value in field t.Did was too long")
3392 }
3393
3394 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil {
3395 return err
3396 }
3397 if _, err := cw.WriteString(string(t.Did)); err != nil {
3398 return err
3399 }
3400
3401 // t.LexiconTypeID (string) (string)
3402 if len("$type") > 1000000 {
3403 return xerrors.Errorf("Value in field \"$type\" was too long")
3404 }
3405
3406 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3407 return err
3408 }
3409 if _, err := cw.WriteString(string("$type")); err != nil {
3410 return err
3411 }
3412
3413 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.star#repo"))); err != nil {
3414 return err
3415 }
3416 if _, err := cw.WriteString(string("sh.tangled.feed.star#repo")); err != nil {
3417 return err
3418 }
3419 return nil
3420}
3421
3422func (t *FeedStar_Repo) UnmarshalCBOR(r io.Reader) (err error) {
3423 *t = FeedStar_Repo{}
3424
3425 cr := cbg.NewCborReader(r)
3426
3427 maj, extra, err := cr.ReadHeader()
3428 if err != nil {
3429 return err
3430 }
3431 defer func() {
3432 if err == io.EOF {
3433 err = io.ErrUnexpectedEOF
3434 }
3435 }()
3436
3437 if maj != cbg.MajMap {
3438 return fmt.Errorf("cbor input should be of type map")
3439 }
3440
3441 if extra > cbg.MaxLength {
3442 return fmt.Errorf("FeedStar_Repo: map struct too large (%d)", extra)
3443 }
3444
3445 n := extra
3446
3447 nameBuf := make([]byte, 5)
3448 for i := uint64(0); i < n; i++ {
3449 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3450 if err != nil {
3451 return err
3452 }
3453
3454 if !ok {
3455 // Field doesn't exist on this type, so ignore it
3456 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3457 return err
3458 }
3459 continue
3460 }
3461
3462 switch string(nameBuf[:nameLen]) {
3463 // t.Did (string) (string)
3464 case "did":
3465
3466 {
3467 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3468 if err != nil {
3469 return err
3470 }
3471
3472 t.Did = string(sval)
3473 }
3474 // t.LexiconTypeID (string) (string)
3475 case "$type":
3476
3477 {
3478 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3479 if err != nil {
3480 return err
3481 }
3482
3483 t.LexiconTypeID = string(sval)
3484 }
3485
3486 default:
3487 // Field doesn't exist on this type, so ignore it
3488 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3489 return err
3490 }
3491 }
3492 }
3493
3494 return nil
3495}
3496func (t *FeedStar_String) MarshalCBOR(w io.Writer) error {
3497 if t == nil {
3498 _, err := w.Write(cbg.CborNull)
3499 return err
3500 }
3501
3502 cw := cbg.NewCborWriter(w)
3503
3504 if _, err := cw.Write([]byte{162}); err != nil {
3505 return err
3506 }
3507
3508 // t.Uri (string) (string)
3509 if len("uri") > 1000000 {
3510 return xerrors.Errorf("Value in field \"uri\" was too long")
3511 }
3512
3513 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("uri"))); err != nil {
3514 return err
3515 }
3516 if _, err := cw.WriteString(string("uri")); err != nil {
3517 return err
3518 }
3519
3520 if len(t.Uri) > 1000000 {
3521 return xerrors.Errorf("Value in field t.Uri was too long")
3522 }
3523
3524 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Uri))); err != nil {
3525 return err
3526 }
3527 if _, err := cw.WriteString(string(t.Uri)); err != nil {
3528 return err
3529 }
3530
3531 // t.LexiconTypeID (string) (string)
3532 if len("$type") > 1000000 {
3533 return xerrors.Errorf("Value in field \"$type\" was too long")
3534 }
3535
3536 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3537 return err
3538 }
3539 if _, err := cw.WriteString(string("$type")); err != nil {
3540 return err
3541 }
3542
3543 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.star#string"))); err != nil {
3544 return err
3545 }
3546 if _, err := cw.WriteString(string("sh.tangled.feed.star#string")); err != nil {
3547 return err
3548 }
3549 return nil
3550}
3551
3552func (t *FeedStar_String) UnmarshalCBOR(r io.Reader) (err error) {
3553 *t = FeedStar_String{}
3554
3555 cr := cbg.NewCborReader(r)
3556
3557 maj, extra, err := cr.ReadHeader()
3558 if err != nil {
3559 return err
3560 }
3561 defer func() {
3562 if err == io.EOF {
3563 err = io.ErrUnexpectedEOF
3564 }
3565 }()
3566
3567 if maj != cbg.MajMap {
3568 return fmt.Errorf("cbor input should be of type map")
3569 }
3570
3571 if extra > cbg.MaxLength {
3572 return fmt.Errorf("FeedStar_String: map struct too large (%d)", extra)
3573 }
3574
3575 n := extra
3576
3577 nameBuf := make([]byte, 5)
3578 for i := uint64(0); i < n; i++ {
3579 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3580 if err != nil {
3581 return err
3582 }
3583
3584 if !ok {
3585 // Field doesn't exist on this type, so ignore it
3586 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3587 return err
3588 }
3589 continue
3590 }
3591
3592 switch string(nameBuf[:nameLen]) {
3593 // t.Uri (string) (string)
3594 case "uri":
3595
3596 {
3597 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3598 if err != nil {
3599 return err
3600 }
3601
3602 t.Uri = string(sval)
3603 }
3604 // t.LexiconTypeID (string) (string)
3605 case "$type":
3606
3607 {
3608 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3609 if err != nil {
3610 return err
3611 }
3612
3613 t.LexiconTypeID = string(sval)
3614 }
3615
3616 default:
3617 // Field doesn't exist on this type, so ignore it
3618 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3619 return err
3620 }
3621 }
3622 }
3623
3624 return nil
3625}
3626func (t *GitRefUpdate) MarshalCBOR(w io.Writer) error {
3627 if t == nil {
3628 _, err := w.Write(cbg.CborNull)
3629 return err
3630 }
3631
3632 cw := cbg.NewCborWriter(w)
3633 fieldCount := 10
3634
3635 if t.ChangedFiles == nil {
3636 fieldCount--
3637 }
3638
3639 if t.OwnerDid == nil {
3640 fieldCount--
3641 }
3642
3643 if t.PushOptions == nil {
3644 fieldCount--
3645 }
3646
3647 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3648 return err
3649 }
3650
3651 // t.Ref (string) (string)
3652 if len("ref") > 1000000 {
3653 return xerrors.Errorf("Value in field \"ref\" was too long")
3654 }
3655
3656 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
3657 return err
3658 }
3659 if _, err := cw.WriteString(string("ref")); err != nil {
3660 return err
3661 }
3662
3663 if len(t.Ref) > 1000000 {
3664 return xerrors.Errorf("Value in field t.Ref was too long")
3665 }
3666
3667 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
3668 return err
3669 }
3670 if _, err := cw.WriteString(string(t.Ref)); err != nil {
3671 return err
3672 }
3673
3674 // t.Meta (tangled.GitRefUpdate_Meta) (struct)
3675 if len("meta") > 1000000 {
3676 return xerrors.Errorf("Value in field \"meta\" was too long")
3677 }
3678
3679 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil {
3680 return err
3681 }
3682 if _, err := cw.WriteString(string("meta")); err != nil {
3683 return err
3684 }
3685
3686 if err := t.Meta.MarshalCBOR(cw); err != nil {
3687 return err
3688 }
3689
3690 // t.Repo (string) (string)
3691 if len("repo") > 1000000 {
3692 return xerrors.Errorf("Value in field \"repo\" was too long")
3693 }
3694
3695 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
3696 return err
3697 }
3698 if _, err := cw.WriteString(string("repo")); err != nil {
3699 return err
3700 }
3701
3702 if len(t.Repo) > 1000000 {
3703 return xerrors.Errorf("Value in field t.Repo was too long")
3704 }
3705
3706 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
3707 return err
3708 }
3709 if _, err := cw.WriteString(string(t.Repo)); err != nil {
3710 return err
3711 }
3712
3713 // t.LexiconTypeID (string) (string)
3714 if len("$type") > 1000000 {
3715 return xerrors.Errorf("Value in field \"$type\" was too long")
3716 }
3717
3718 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3719 return err
3720 }
3721 if _, err := cw.WriteString(string("$type")); err != nil {
3722 return err
3723 }
3724
3725 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.git.refUpdate"))); err != nil {
3726 return err
3727 }
3728 if _, err := cw.WriteString(string("sh.tangled.git.refUpdate")); err != nil {
3729 return err
3730 }
3731
3732 // t.NewSha (string) (string)
3733 if len("newSha") > 1000000 {
3734 return xerrors.Errorf("Value in field \"newSha\" was too long")
3735 }
3736
3737 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
3738 return err
3739 }
3740 if _, err := cw.WriteString(string("newSha")); err != nil {
3741 return err
3742 }
3743
3744 if len(t.NewSha) > 1000000 {
3745 return xerrors.Errorf("Value in field t.NewSha was too long")
3746 }
3747
3748 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
3749 return err
3750 }
3751 if _, err := cw.WriteString(string(t.NewSha)); err != nil {
3752 return err
3753 }
3754
3755 // t.OldSha (string) (string)
3756 if len("oldSha") > 1000000 {
3757 return xerrors.Errorf("Value in field \"oldSha\" was too long")
3758 }
3759
3760 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
3761 return err
3762 }
3763 if _, err := cw.WriteString(string("oldSha")); err != nil {
3764 return err
3765 }
3766
3767 if len(t.OldSha) > 1000000 {
3768 return xerrors.Errorf("Value in field t.OldSha was too long")
3769 }
3770
3771 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
3772 return err
3773 }
3774 if _, err := cw.WriteString(string(t.OldSha)); err != nil {
3775 return err
3776 }
3777
3778 // t.OwnerDid (string) (string)
3779 if t.OwnerDid != nil {
3780
3781 if len("ownerDid") > 1000000 {
3782 return xerrors.Errorf("Value in field \"ownerDid\" was too long")
3783 }
3784
3785 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ownerDid"))); err != nil {
3786 return err
3787 }
3788 if _, err := cw.WriteString(string("ownerDid")); err != nil {
3789 return err
3790 }
3791
3792 if t.OwnerDid == nil {
3793 if _, err := cw.Write(cbg.CborNull); err != nil {
3794 return err
3795 }
3796 } else {
3797 if len(*t.OwnerDid) > 1000000 {
3798 return xerrors.Errorf("Value in field t.OwnerDid was too long")
3799 }
3800
3801 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.OwnerDid))); err != nil {
3802 return err
3803 }
3804 if _, err := cw.WriteString(string(*t.OwnerDid)); err != nil {
3805 return err
3806 }
3807 }
3808 }
3809
3810 // t.PushOptions ([]string) (slice)
3811 if t.PushOptions != nil {
3812
3813 if len("pushOptions") > 1000000 {
3814 return xerrors.Errorf("Value in field \"pushOptions\" was too long")
3815 }
3816
3817 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pushOptions"))); err != nil {
3818 return err
3819 }
3820 if _, err := cw.WriteString(string("pushOptions")); err != nil {
3821 return err
3822 }
3823
3824 if len(t.PushOptions) > 8192 {
3825 return xerrors.Errorf("Slice value in field t.PushOptions was too long")
3826 }
3827
3828 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.PushOptions))); err != nil {
3829 return err
3830 }
3831 for _, v := range t.PushOptions {
3832 if len(v) > 1000000 {
3833 return xerrors.Errorf("Value in field v was too long")
3834 }
3835
3836 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
3837 return err
3838 }
3839 if _, err := cw.WriteString(string(v)); err != nil {
3840 return err
3841 }
3842
3843 }
3844 }
3845
3846 // t.ChangedFiles ([]string) (slice)
3847 if t.ChangedFiles != nil {
3848
3849 if len("changedFiles") > 1000000 {
3850 return xerrors.Errorf("Value in field \"changedFiles\" was too long")
3851 }
3852
3853 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("changedFiles"))); err != nil {
3854 return err
3855 }
3856 if _, err := cw.WriteString(string("changedFiles")); err != nil {
3857 return err
3858 }
3859
3860 if len(t.ChangedFiles) > 8192 {
3861 return xerrors.Errorf("Slice value in field t.ChangedFiles was too long")
3862 }
3863
3864 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ChangedFiles))); err != nil {
3865 return err
3866 }
3867 for _, v := range t.ChangedFiles {
3868 if len(v) > 1000000 {
3869 return xerrors.Errorf("Value in field v was too long")
3870 }
3871
3872 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
3873 return err
3874 }
3875 if _, err := cw.WriteString(string(v)); err != nil {
3876 return err
3877 }
3878
3879 }
3880 }
3881
3882 // t.CommitterDid (string) (string)
3883 if len("committerDid") > 1000000 {
3884 return xerrors.Errorf("Value in field \"committerDid\" was too long")
3885 }
3886
3887 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("committerDid"))); err != nil {
3888 return err
3889 }
3890 if _, err := cw.WriteString(string("committerDid")); err != nil {
3891 return err
3892 }
3893
3894 if len(t.CommitterDid) > 1000000 {
3895 return xerrors.Errorf("Value in field t.CommitterDid was too long")
3896 }
3897
3898 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CommitterDid))); err != nil {
3899 return err
3900 }
3901 if _, err := cw.WriteString(string(t.CommitterDid)); err != nil {
3902 return err
3903 }
3904 return nil
3905}
3906
3907func (t *GitRefUpdate) UnmarshalCBOR(r io.Reader) (err error) {
3908 *t = GitRefUpdate{}
3909
3910 cr := cbg.NewCborReader(r)
3911
3912 maj, extra, err := cr.ReadHeader()
3913 if err != nil {
3914 return err
3915 }
3916 defer func() {
3917 if err == io.EOF {
3918 err = io.ErrUnexpectedEOF
3919 }
3920 }()
3921
3922 if maj != cbg.MajMap {
3923 return fmt.Errorf("cbor input should be of type map")
3924 }
3925
3926 if extra > cbg.MaxLength {
3927 return fmt.Errorf("GitRefUpdate: map struct too large (%d)", extra)
3928 }
3929
3930 n := extra
3931
3932 nameBuf := make([]byte, 12)
3933 for i := uint64(0); i < n; i++ {
3934 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3935 if err != nil {
3936 return err
3937 }
3938
3939 if !ok {
3940 // Field doesn't exist on this type, so ignore it
3941 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3942 return err
3943 }
3944 continue
3945 }
3946
3947 switch string(nameBuf[:nameLen]) {
3948 // t.Ref (string) (string)
3949 case "ref":
3950
3951 {
3952 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3953 if err != nil {
3954 return err
3955 }
3956
3957 t.Ref = string(sval)
3958 }
3959 // t.Meta (tangled.GitRefUpdate_Meta) (struct)
3960 case "meta":
3961
3962 {
3963
3964 b, err := cr.ReadByte()
3965 if err != nil {
3966 return err
3967 }
3968 if b != cbg.CborNull[0] {
3969 if err := cr.UnreadByte(); err != nil {
3970 return err
3971 }
3972 t.Meta = new(GitRefUpdate_Meta)
3973 if err := t.Meta.UnmarshalCBOR(cr); err != nil {
3974 return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err)
3975 }
3976 }
3977
3978 }
3979 // t.Repo (string) (string)
3980 case "repo":
3981
3982 {
3983 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3984 if err != nil {
3985 return err
3986 }
3987
3988 t.Repo = string(sval)
3989 }
3990 // t.LexiconTypeID (string) (string)
3991 case "$type":
3992
3993 {
3994 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3995 if err != nil {
3996 return err
3997 }
3998
3999 t.LexiconTypeID = string(sval)
4000 }
4001 // t.NewSha (string) (string)
4002 case "newSha":
4003
4004 {
4005 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4006 if err != nil {
4007 return err
4008 }
4009
4010 t.NewSha = string(sval)
4011 }
4012 // t.OldSha (string) (string)
4013 case "oldSha":
4014
4015 {
4016 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4017 if err != nil {
4018 return err
4019 }
4020
4021 t.OldSha = string(sval)
4022 }
4023 // t.OwnerDid (string) (string)
4024 case "ownerDid":
4025
4026 {
4027 b, err := cr.ReadByte()
4028 if err != nil {
4029 return err
4030 }
4031 if b != cbg.CborNull[0] {
4032 if err := cr.UnreadByte(); err != nil {
4033 return err
4034 }
4035
4036 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4037 if err != nil {
4038 return err
4039 }
4040
4041 t.OwnerDid = (*string)(&sval)
4042 }
4043 }
4044 // t.PushOptions ([]string) (slice)
4045 case "pushOptions":
4046
4047 maj, extra, err = cr.ReadHeader()
4048 if err != nil {
4049 return err
4050 }
4051
4052 if extra > 8192 {
4053 return fmt.Errorf("t.PushOptions: array too large (%d)", extra)
4054 }
4055
4056 if maj != cbg.MajArray {
4057 return fmt.Errorf("expected cbor array")
4058 }
4059
4060 if extra > 0 {
4061 t.PushOptions = make([]string, extra)
4062 }
4063
4064 for i := 0; i < int(extra); i++ {
4065 {
4066 var maj byte
4067 var extra uint64
4068 var err error
4069 _ = maj
4070 _ = extra
4071 _ = err
4072
4073 {
4074 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4075 if err != nil {
4076 return err
4077 }
4078
4079 t.PushOptions[i] = string(sval)
4080 }
4081
4082 }
4083 }
4084 // t.ChangedFiles ([]string) (slice)
4085 case "changedFiles":
4086
4087 maj, extra, err = cr.ReadHeader()
4088 if err != nil {
4089 return err
4090 }
4091
4092 if extra > 8192 {
4093 return fmt.Errorf("t.ChangedFiles: array too large (%d)", extra)
4094 }
4095
4096 if maj != cbg.MajArray {
4097 return fmt.Errorf("expected cbor array")
4098 }
4099
4100 if extra > 0 {
4101 t.ChangedFiles = make([]string, extra)
4102 }
4103
4104 for i := 0; i < int(extra); i++ {
4105 {
4106 var maj byte
4107 var extra uint64
4108 var err error
4109 _ = maj
4110 _ = extra
4111 _ = err
4112
4113 {
4114 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4115 if err != nil {
4116 return err
4117 }
4118
4119 t.ChangedFiles[i] = string(sval)
4120 }
4121
4122 }
4123 }
4124 // t.CommitterDid (string) (string)
4125 case "committerDid":
4126
4127 {
4128 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4129 if err != nil {
4130 return err
4131 }
4132
4133 t.CommitterDid = string(sval)
4134 }
4135
4136 default:
4137 // Field doesn't exist on this type, so ignore it
4138 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4139 return err
4140 }
4141 }
4142 }
4143
4144 return nil
4145}
4146func (t *GitRefUpdate_CommitCountBreakdown) MarshalCBOR(w io.Writer) error {
4147 if t == nil {
4148 _, err := w.Write(cbg.CborNull)
4149 return err
4150 }
4151
4152 cw := cbg.NewCborWriter(w)
4153 fieldCount := 1
4154
4155 if t.ByEmail == nil {
4156 fieldCount--
4157 }
4158
4159 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4160 return err
4161 }
4162
4163 // t.ByEmail ([]*tangled.GitRefUpdate_IndividualEmailCommitCount) (slice)
4164 if t.ByEmail != nil {
4165
4166 if len("byEmail") > 1000000 {
4167 return xerrors.Errorf("Value in field \"byEmail\" was too long")
4168 }
4169
4170 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byEmail"))); err != nil {
4171 return err
4172 }
4173 if _, err := cw.WriteString(string("byEmail")); err != nil {
4174 return err
4175 }
4176
4177 if len(t.ByEmail) > 8192 {
4178 return xerrors.Errorf("Slice value in field t.ByEmail was too long")
4179 }
4180
4181 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ByEmail))); err != nil {
4182 return err
4183 }
4184 for _, v := range t.ByEmail {
4185 if err := v.MarshalCBOR(cw); err != nil {
4186 return err
4187 }
4188
4189 }
4190 }
4191 return nil
4192}
4193
4194func (t *GitRefUpdate_CommitCountBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
4195 *t = GitRefUpdate_CommitCountBreakdown{}
4196
4197 cr := cbg.NewCborReader(r)
4198
4199 maj, extra, err := cr.ReadHeader()
4200 if err != nil {
4201 return err
4202 }
4203 defer func() {
4204 if err == io.EOF {
4205 err = io.ErrUnexpectedEOF
4206 }
4207 }()
4208
4209 if maj != cbg.MajMap {
4210 return fmt.Errorf("cbor input should be of type map")
4211 }
4212
4213 if extra > cbg.MaxLength {
4214 return fmt.Errorf("GitRefUpdate_CommitCountBreakdown: map struct too large (%d)", extra)
4215 }
4216
4217 n := extra
4218
4219 nameBuf := make([]byte, 7)
4220 for i := uint64(0); i < n; i++ {
4221 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4222 if err != nil {
4223 return err
4224 }
4225
4226 if !ok {
4227 // Field doesn't exist on this type, so ignore it
4228 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4229 return err
4230 }
4231 continue
4232 }
4233
4234 switch string(nameBuf[:nameLen]) {
4235 // t.ByEmail ([]*tangled.GitRefUpdate_IndividualEmailCommitCount) (slice)
4236 case "byEmail":
4237
4238 maj, extra, err = cr.ReadHeader()
4239 if err != nil {
4240 return err
4241 }
4242
4243 if extra > 8192 {
4244 return fmt.Errorf("t.ByEmail: array too large (%d)", extra)
4245 }
4246
4247 if maj != cbg.MajArray {
4248 return fmt.Errorf("expected cbor array")
4249 }
4250
4251 if extra > 0 {
4252 t.ByEmail = make([]*GitRefUpdate_IndividualEmailCommitCount, extra)
4253 }
4254
4255 for i := 0; i < int(extra); i++ {
4256 {
4257 var maj byte
4258 var extra uint64
4259 var err error
4260 _ = maj
4261 _ = extra
4262 _ = err
4263
4264 {
4265
4266 b, err := cr.ReadByte()
4267 if err != nil {
4268 return err
4269 }
4270 if b != cbg.CborNull[0] {
4271 if err := cr.UnreadByte(); err != nil {
4272 return err
4273 }
4274 t.ByEmail[i] = new(GitRefUpdate_IndividualEmailCommitCount)
4275 if err := t.ByEmail[i].UnmarshalCBOR(cr); err != nil {
4276 return xerrors.Errorf("unmarshaling t.ByEmail[i] pointer: %w", err)
4277 }
4278 }
4279
4280 }
4281
4282 }
4283 }
4284
4285 default:
4286 // Field doesn't exist on this type, so ignore it
4287 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4288 return err
4289 }
4290 }
4291 }
4292
4293 return nil
4294}
4295func (t *GitRefUpdate_IndividualEmailCommitCount) MarshalCBOR(w io.Writer) error {
4296 if t == nil {
4297 _, err := w.Write(cbg.CborNull)
4298 return err
4299 }
4300
4301 cw := cbg.NewCborWriter(w)
4302
4303 if _, err := cw.Write([]byte{162}); err != nil {
4304 return err
4305 }
4306
4307 // t.Count (int64) (int64)
4308 if len("count") > 1000000 {
4309 return xerrors.Errorf("Value in field \"count\" was too long")
4310 }
4311
4312 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("count"))); err != nil {
4313 return err
4314 }
4315 if _, err := cw.WriteString(string("count")); err != nil {
4316 return err
4317 }
4318
4319 if t.Count >= 0 {
4320 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Count)); err != nil {
4321 return err
4322 }
4323 } else {
4324 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Count-1)); err != nil {
4325 return err
4326 }
4327 }
4328
4329 // t.Email (string) (string)
4330 if len("email") > 1000000 {
4331 return xerrors.Errorf("Value in field \"email\" was too long")
4332 }
4333
4334 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("email"))); err != nil {
4335 return err
4336 }
4337 if _, err := cw.WriteString(string("email")); err != nil {
4338 return err
4339 }
4340
4341 if len(t.Email) > 1000000 {
4342 return xerrors.Errorf("Value in field t.Email was too long")
4343 }
4344
4345 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Email))); err != nil {
4346 return err
4347 }
4348 if _, err := cw.WriteString(string(t.Email)); err != nil {
4349 return err
4350 }
4351 return nil
4352}
4353
4354func (t *GitRefUpdate_IndividualEmailCommitCount) UnmarshalCBOR(r io.Reader) (err error) {
4355 *t = GitRefUpdate_IndividualEmailCommitCount{}
4356
4357 cr := cbg.NewCborReader(r)
4358
4359 maj, extra, err := cr.ReadHeader()
4360 if err != nil {
4361 return err
4362 }
4363 defer func() {
4364 if err == io.EOF {
4365 err = io.ErrUnexpectedEOF
4366 }
4367 }()
4368
4369 if maj != cbg.MajMap {
4370 return fmt.Errorf("cbor input should be of type map")
4371 }
4372
4373 if extra > cbg.MaxLength {
4374 return fmt.Errorf("GitRefUpdate_IndividualEmailCommitCount: map struct too large (%d)", extra)
4375 }
4376
4377 n := extra
4378
4379 nameBuf := make([]byte, 5)
4380 for i := uint64(0); i < n; i++ {
4381 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4382 if err != nil {
4383 return err
4384 }
4385
4386 if !ok {
4387 // Field doesn't exist on this type, so ignore it
4388 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4389 return err
4390 }
4391 continue
4392 }
4393
4394 switch string(nameBuf[:nameLen]) {
4395 // t.Count (int64) (int64)
4396 case "count":
4397 {
4398 maj, extra, err := cr.ReadHeader()
4399 if err != nil {
4400 return err
4401 }
4402 var extraI int64
4403 switch maj {
4404 case cbg.MajUnsignedInt:
4405 extraI = int64(extra)
4406 if extraI < 0 {
4407 return fmt.Errorf("int64 positive overflow")
4408 }
4409 case cbg.MajNegativeInt:
4410 extraI = int64(extra)
4411 if extraI < 0 {
4412 return fmt.Errorf("int64 negative overflow")
4413 }
4414 extraI = -1 - extraI
4415 default:
4416 return fmt.Errorf("wrong type for int64 field: %d", maj)
4417 }
4418
4419 t.Count = int64(extraI)
4420 }
4421 // t.Email (string) (string)
4422 case "email":
4423
4424 {
4425 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4426 if err != nil {
4427 return err
4428 }
4429
4430 t.Email = string(sval)
4431 }
4432
4433 default:
4434 // Field doesn't exist on this type, so ignore it
4435 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4436 return err
4437 }
4438 }
4439 }
4440
4441 return nil
4442}
4443func (t *GitRefUpdate_IndividualLanguageSize) MarshalCBOR(w io.Writer) error {
4444 if t == nil {
4445 _, err := w.Write(cbg.CborNull)
4446 return err
4447 }
4448
4449 cw := cbg.NewCborWriter(w)
4450
4451 if _, err := cw.Write([]byte{162}); err != nil {
4452 return err
4453 }
4454
4455 // t.Lang (string) (string)
4456 if len("lang") > 1000000 {
4457 return xerrors.Errorf("Value in field \"lang\" was too long")
4458 }
4459
4460 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil {
4461 return err
4462 }
4463 if _, err := cw.WriteString(string("lang")); err != nil {
4464 return err
4465 }
4466
4467 if len(t.Lang) > 1000000 {
4468 return xerrors.Errorf("Value in field t.Lang was too long")
4469 }
4470
4471 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil {
4472 return err
4473 }
4474 if _, err := cw.WriteString(string(t.Lang)); err != nil {
4475 return err
4476 }
4477
4478 // t.Size (int64) (int64)
4479 if len("size") > 1000000 {
4480 return xerrors.Errorf("Value in field \"size\" was too long")
4481 }
4482
4483 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil {
4484 return err
4485 }
4486 if _, err := cw.WriteString(string("size")); err != nil {
4487 return err
4488 }
4489
4490 if t.Size >= 0 {
4491 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil {
4492 return err
4493 }
4494 } else {
4495 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); err != nil {
4496 return err
4497 }
4498 }
4499
4500 return nil
4501}
4502
4503func (t *GitRefUpdate_IndividualLanguageSize) UnmarshalCBOR(r io.Reader) (err error) {
4504 *t = GitRefUpdate_IndividualLanguageSize{}
4505
4506 cr := cbg.NewCborReader(r)
4507
4508 maj, extra, err := cr.ReadHeader()
4509 if err != nil {
4510 return err
4511 }
4512 defer func() {
4513 if err == io.EOF {
4514 err = io.ErrUnexpectedEOF
4515 }
4516 }()
4517
4518 if maj != cbg.MajMap {
4519 return fmt.Errorf("cbor input should be of type map")
4520 }
4521
4522 if extra > cbg.MaxLength {
4523 return fmt.Errorf("GitRefUpdate_IndividualLanguageSize: map struct too large (%d)", extra)
4524 }
4525
4526 n := extra
4527
4528 nameBuf := make([]byte, 4)
4529 for i := uint64(0); i < n; i++ {
4530 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4531 if err != nil {
4532 return err
4533 }
4534
4535 if !ok {
4536 // Field doesn't exist on this type, so ignore it
4537 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4538 return err
4539 }
4540 continue
4541 }
4542
4543 switch string(nameBuf[:nameLen]) {
4544 // t.Lang (string) (string)
4545 case "lang":
4546
4547 {
4548 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4549 if err != nil {
4550 return err
4551 }
4552
4553 t.Lang = string(sval)
4554 }
4555 // t.Size (int64) (int64)
4556 case "size":
4557 {
4558 maj, extra, err := cr.ReadHeader()
4559 if err != nil {
4560 return err
4561 }
4562 var extraI int64
4563 switch maj {
4564 case cbg.MajUnsignedInt:
4565 extraI = int64(extra)
4566 if extraI < 0 {
4567 return fmt.Errorf("int64 positive overflow")
4568 }
4569 case cbg.MajNegativeInt:
4570 extraI = int64(extra)
4571 if extraI < 0 {
4572 return fmt.Errorf("int64 negative overflow")
4573 }
4574 extraI = -1 - extraI
4575 default:
4576 return fmt.Errorf("wrong type for int64 field: %d", maj)
4577 }
4578
4579 t.Size = int64(extraI)
4580 }
4581
4582 default:
4583 // Field doesn't exist on this type, so ignore it
4584 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4585 return err
4586 }
4587 }
4588 }
4589
4590 return nil
4591}
4592func (t *GitRefUpdate_LangBreakdown) MarshalCBOR(w io.Writer) error {
4593 if t == nil {
4594 _, err := w.Write(cbg.CborNull)
4595 return err
4596 }
4597
4598 cw := cbg.NewCborWriter(w)
4599 fieldCount := 1
4600
4601 if t.Inputs == nil {
4602 fieldCount--
4603 }
4604
4605 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4606 return err
4607 }
4608
4609 // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice)
4610 if t.Inputs != nil {
4611
4612 if len("inputs") > 1000000 {
4613 return xerrors.Errorf("Value in field \"inputs\" was too long")
4614 }
4615
4616 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
4617 return err
4618 }
4619 if _, err := cw.WriteString(string("inputs")); err != nil {
4620 return err
4621 }
4622
4623 if len(t.Inputs) > 8192 {
4624 return xerrors.Errorf("Slice value in field t.Inputs was too long")
4625 }
4626
4627 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
4628 return err
4629 }
4630 for _, v := range t.Inputs {
4631 if err := v.MarshalCBOR(cw); err != nil {
4632 return err
4633 }
4634
4635 }
4636 }
4637 return nil
4638}
4639
4640func (t *GitRefUpdate_LangBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
4641 *t = GitRefUpdate_LangBreakdown{}
4642
4643 cr := cbg.NewCborReader(r)
4644
4645 maj, extra, err := cr.ReadHeader()
4646 if err != nil {
4647 return err
4648 }
4649 defer func() {
4650 if err == io.EOF {
4651 err = io.ErrUnexpectedEOF
4652 }
4653 }()
4654
4655 if maj != cbg.MajMap {
4656 return fmt.Errorf("cbor input should be of type map")
4657 }
4658
4659 if extra > cbg.MaxLength {
4660 return fmt.Errorf("GitRefUpdate_LangBreakdown: map struct too large (%d)", extra)
4661 }
4662
4663 n := extra
4664
4665 nameBuf := make([]byte, 6)
4666 for i := uint64(0); i < n; i++ {
4667 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4668 if err != nil {
4669 return err
4670 }
4671
4672 if !ok {
4673 // Field doesn't exist on this type, so ignore it
4674 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4675 return err
4676 }
4677 continue
4678 }
4679
4680 switch string(nameBuf[:nameLen]) {
4681 // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice)
4682 case "inputs":
4683
4684 maj, extra, err = cr.ReadHeader()
4685 if err != nil {
4686 return err
4687 }
4688
4689 if extra > 8192 {
4690 return fmt.Errorf("t.Inputs: array too large (%d)", extra)
4691 }
4692
4693 if maj != cbg.MajArray {
4694 return fmt.Errorf("expected cbor array")
4695 }
4696
4697 if extra > 0 {
4698 t.Inputs = make([]*GitRefUpdate_IndividualLanguageSize, extra)
4699 }
4700
4701 for i := 0; i < int(extra); i++ {
4702 {
4703 var maj byte
4704 var extra uint64
4705 var err error
4706 _ = maj
4707 _ = extra
4708 _ = err
4709
4710 {
4711
4712 b, err := cr.ReadByte()
4713 if err != nil {
4714 return err
4715 }
4716 if b != cbg.CborNull[0] {
4717 if err := cr.UnreadByte(); err != nil {
4718 return err
4719 }
4720 t.Inputs[i] = new(GitRefUpdate_IndividualLanguageSize)
4721 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
4722 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
4723 }
4724 }
4725
4726 }
4727
4728 }
4729 }
4730
4731 default:
4732 // Field doesn't exist on this type, so ignore it
4733 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4734 return err
4735 }
4736 }
4737 }
4738
4739 return nil
4740}
4741func (t *GitRefUpdate_Meta) MarshalCBOR(w io.Writer) error {
4742 if t == nil {
4743 _, err := w.Write(cbg.CborNull)
4744 return err
4745 }
4746
4747 cw := cbg.NewCborWriter(w)
4748 fieldCount := 3
4749
4750 if t.LangBreakdown == nil {
4751 fieldCount--
4752 }
4753
4754 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4755 return err
4756 }
4757
4758 // t.CommitCount (tangled.GitRefUpdate_CommitCountBreakdown) (struct)
4759 if len("commitCount") > 1000000 {
4760 return xerrors.Errorf("Value in field \"commitCount\" was too long")
4761 }
4762
4763 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commitCount"))); err != nil {
4764 return err
4765 }
4766 if _, err := cw.WriteString(string("commitCount")); err != nil {
4767 return err
4768 }
4769
4770 if err := t.CommitCount.MarshalCBOR(cw); err != nil {
4771 return err
4772 }
4773
4774 // t.IsDefaultRef (bool) (bool)
4775 if len("isDefaultRef") > 1000000 {
4776 return xerrors.Errorf("Value in field \"isDefaultRef\" was too long")
4777 }
4778
4779 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("isDefaultRef"))); err != nil {
4780 return err
4781 }
4782 if _, err := cw.WriteString(string("isDefaultRef")); err != nil {
4783 return err
4784 }
4785
4786 if err := cbg.WriteBool(w, t.IsDefaultRef); err != nil {
4787 return err
4788 }
4789
4790 // t.LangBreakdown (tangled.GitRefUpdate_LangBreakdown) (struct)
4791 if t.LangBreakdown != nil {
4792
4793 if len("langBreakdown") > 1000000 {
4794 return xerrors.Errorf("Value in field \"langBreakdown\" was too long")
4795 }
4796
4797 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("langBreakdown"))); err != nil {
4798 return err
4799 }
4800 if _, err := cw.WriteString(string("langBreakdown")); err != nil {
4801 return err
4802 }
4803
4804 if err := t.LangBreakdown.MarshalCBOR(cw); err != nil {
4805 return err
4806 }
4807 }
4808 return nil
4809}
4810
4811func (t *GitRefUpdate_Meta) UnmarshalCBOR(r io.Reader) (err error) {
4812 *t = GitRefUpdate_Meta{}
4813
4814 cr := cbg.NewCborReader(r)
4815
4816 maj, extra, err := cr.ReadHeader()
4817 if err != nil {
4818 return err
4819 }
4820 defer func() {
4821 if err == io.EOF {
4822 err = io.ErrUnexpectedEOF
4823 }
4824 }()
4825
4826 if maj != cbg.MajMap {
4827 return fmt.Errorf("cbor input should be of type map")
4828 }
4829
4830 if extra > cbg.MaxLength {
4831 return fmt.Errorf("GitRefUpdate_Meta: map struct too large (%d)", extra)
4832 }
4833
4834 n := extra
4835
4836 nameBuf := make([]byte, 13)
4837 for i := uint64(0); i < n; i++ {
4838 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4839 if err != nil {
4840 return err
4841 }
4842
4843 if !ok {
4844 // Field doesn't exist on this type, so ignore it
4845 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4846 return err
4847 }
4848 continue
4849 }
4850
4851 switch string(nameBuf[:nameLen]) {
4852 // t.CommitCount (tangled.GitRefUpdate_CommitCountBreakdown) (struct)
4853 case "commitCount":
4854
4855 {
4856
4857 b, err := cr.ReadByte()
4858 if err != nil {
4859 return err
4860 }
4861 if b != cbg.CborNull[0] {
4862 if err := cr.UnreadByte(); err != nil {
4863 return err
4864 }
4865 t.CommitCount = new(GitRefUpdate_CommitCountBreakdown)
4866 if err := t.CommitCount.UnmarshalCBOR(cr); err != nil {
4867 return xerrors.Errorf("unmarshaling t.CommitCount pointer: %w", err)
4868 }
4869 }
4870
4871 }
4872 // t.IsDefaultRef (bool) (bool)
4873 case "isDefaultRef":
4874
4875 maj, extra, err = cr.ReadHeader()
4876 if err != nil {
4877 return err
4878 }
4879 if maj != cbg.MajOther {
4880 return fmt.Errorf("booleans must be major type 7")
4881 }
4882 switch extra {
4883 case 20:
4884 t.IsDefaultRef = false
4885 case 21:
4886 t.IsDefaultRef = true
4887 default:
4888 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
4889 }
4890 // t.LangBreakdown (tangled.GitRefUpdate_LangBreakdown) (struct)
4891 case "langBreakdown":
4892
4893 {
4894
4895 b, err := cr.ReadByte()
4896 if err != nil {
4897 return err
4898 }
4899 if b != cbg.CborNull[0] {
4900 if err := cr.UnreadByte(); err != nil {
4901 return err
4902 }
4903 t.LangBreakdown = new(GitRefUpdate_LangBreakdown)
4904 if err := t.LangBreakdown.UnmarshalCBOR(cr); err != nil {
4905 return xerrors.Errorf("unmarshaling t.LangBreakdown pointer: %w", err)
4906 }
4907 }
4908
4909 }
4910
4911 default:
4912 // Field doesn't exist on this type, so ignore it
4913 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4914 return err
4915 }
4916 }
4917 }
4918
4919 return nil
4920}
4921func (t *GraphFollow) MarshalCBOR(w io.Writer) error {
4922 if t == nil {
4923 _, err := w.Write(cbg.CborNull)
4924 return err
4925 }
4926
4927 cw := cbg.NewCborWriter(w)
4928
4929 if _, err := cw.Write([]byte{163}); err != nil {
4930 return err
4931 }
4932
4933 // t.LexiconTypeID (string) (string)
4934 if len("$type") > 1000000 {
4935 return xerrors.Errorf("Value in field \"$type\" was too long")
4936 }
4937
4938 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
4939 return err
4940 }
4941 if _, err := cw.WriteString(string("$type")); err != nil {
4942 return err
4943 }
4944
4945 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.graph.follow"))); err != nil {
4946 return err
4947 }
4948 if _, err := cw.WriteString(string("sh.tangled.graph.follow")); err != nil {
4949 return err
4950 }
4951
4952 // t.Subject (string) (string)
4953 if len("subject") > 1000000 {
4954 return xerrors.Errorf("Value in field \"subject\" was too long")
4955 }
4956
4957 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
4958 return err
4959 }
4960 if _, err := cw.WriteString(string("subject")); err != nil {
4961 return err
4962 }
4963
4964 if len(t.Subject) > 1000000 {
4965 return xerrors.Errorf("Value in field t.Subject was too long")
4966 }
4967
4968 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
4969 return err
4970 }
4971 if _, err := cw.WriteString(string(t.Subject)); err != nil {
4972 return err
4973 }
4974
4975 // t.CreatedAt (string) (string)
4976 if len("createdAt") > 1000000 {
4977 return xerrors.Errorf("Value in field \"createdAt\" was too long")
4978 }
4979
4980 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
4981 return err
4982 }
4983 if _, err := cw.WriteString(string("createdAt")); err != nil {
4984 return err
4985 }
4986
4987 if len(t.CreatedAt) > 1000000 {
4988 return xerrors.Errorf("Value in field t.CreatedAt was too long")
4989 }
4990
4991 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
4992 return err
4993 }
4994 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
4995 return err
4996 }
4997 return nil
4998}
4999
5000func (t *GraphFollow) UnmarshalCBOR(r io.Reader) (err error) {
5001 *t = GraphFollow{}
5002
5003 cr := cbg.NewCborReader(r)
5004
5005 maj, extra, err := cr.ReadHeader()
5006 if err != nil {
5007 return err
5008 }
5009 defer func() {
5010 if err == io.EOF {
5011 err = io.ErrUnexpectedEOF
5012 }
5013 }()
5014
5015 if maj != cbg.MajMap {
5016 return fmt.Errorf("cbor input should be of type map")
5017 }
5018
5019 if extra > cbg.MaxLength {
5020 return fmt.Errorf("GraphFollow: map struct too large (%d)", extra)
5021 }
5022
5023 n := extra
5024
5025 nameBuf := make([]byte, 9)
5026 for i := uint64(0); i < n; i++ {
5027 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5028 if err != nil {
5029 return err
5030 }
5031
5032 if !ok {
5033 // Field doesn't exist on this type, so ignore it
5034 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5035 return err
5036 }
5037 continue
5038 }
5039
5040 switch string(nameBuf[:nameLen]) {
5041 // t.LexiconTypeID (string) (string)
5042 case "$type":
5043
5044 {
5045 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5046 if err != nil {
5047 return err
5048 }
5049
5050 t.LexiconTypeID = string(sval)
5051 }
5052 // t.Subject (string) (string)
5053 case "subject":
5054
5055 {
5056 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5057 if err != nil {
5058 return err
5059 }
5060
5061 t.Subject = string(sval)
5062 }
5063 // t.CreatedAt (string) (string)
5064 case "createdAt":
5065
5066 {
5067 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5068 if err != nil {
5069 return err
5070 }
5071
5072 t.CreatedAt = string(sval)
5073 }
5074
5075 default:
5076 // Field doesn't exist on this type, so ignore it
5077 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5078 return err
5079 }
5080 }
5081 }
5082
5083 return nil
5084}
5085func (t *GraphVouch) MarshalCBOR(w io.Writer) error {
5086 if t == nil {
5087 _, err := w.Write(cbg.CborNull)
5088 return err
5089 }
5090
5091 cw := cbg.NewCborWriter(w)
5092 fieldCount := 5
5093
5094 if t.Evidences == nil {
5095 fieldCount--
5096 }
5097
5098 if t.Reason == nil {
5099 fieldCount--
5100 }
5101
5102 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5103 return err
5104 }
5105
5106 // t.Kind (string) (string)
5107 if len("kind") > 1000000 {
5108 return xerrors.Errorf("Value in field \"kind\" was too long")
5109 }
5110
5111 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("kind"))); err != nil {
5112 return err
5113 }
5114 if _, err := cw.WriteString(string("kind")); err != nil {
5115 return err
5116 }
5117
5118 if len(t.Kind) > 1000000 {
5119 return xerrors.Errorf("Value in field t.Kind was too long")
5120 }
5121
5122 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Kind))); err != nil {
5123 return err
5124 }
5125 if _, err := cw.WriteString(string(t.Kind)); err != nil {
5126 return err
5127 }
5128
5129 // t.LexiconTypeID (string) (string)
5130 if len("$type") > 1000000 {
5131 return xerrors.Errorf("Value in field \"$type\" was too long")
5132 }
5133
5134 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5135 return err
5136 }
5137 if _, err := cw.WriteString(string("$type")); err != nil {
5138 return err
5139 }
5140
5141 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.graph.vouch"))); err != nil {
5142 return err
5143 }
5144 if _, err := cw.WriteString(string("sh.tangled.graph.vouch")); err != nil {
5145 return err
5146 }
5147
5148 // t.Reason (string) (string)
5149 if t.Reason != nil {
5150
5151 if len("reason") > 1000000 {
5152 return xerrors.Errorf("Value in field \"reason\" was too long")
5153 }
5154
5155 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("reason"))); err != nil {
5156 return err
5157 }
5158 if _, err := cw.WriteString(string("reason")); err != nil {
5159 return err
5160 }
5161
5162 if t.Reason == nil {
5163 if _, err := cw.Write(cbg.CborNull); err != nil {
5164 return err
5165 }
5166 } else {
5167 if len(*t.Reason) > 1000000 {
5168 return xerrors.Errorf("Value in field t.Reason was too long")
5169 }
5170
5171 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Reason))); err != nil {
5172 return err
5173 }
5174 if _, err := cw.WriteString(string(*t.Reason)); err != nil {
5175 return err
5176 }
5177 }
5178 }
5179
5180 // t.CreatedAt (string) (string)
5181 if len("createdAt") > 1000000 {
5182 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5183 }
5184
5185 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5186 return err
5187 }
5188 if _, err := cw.WriteString(string("createdAt")); err != nil {
5189 return err
5190 }
5191
5192 if len(t.CreatedAt) > 1000000 {
5193 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5194 }
5195
5196 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5197 return err
5198 }
5199 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5200 return err
5201 }
5202
5203 // t.Evidences ([]string) (slice)
5204 if t.Evidences != nil {
5205
5206 if len("evidences") > 1000000 {
5207 return xerrors.Errorf("Value in field \"evidences\" was too long")
5208 }
5209
5210 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("evidences"))); err != nil {
5211 return err
5212 }
5213 if _, err := cw.WriteString(string("evidences")); err != nil {
5214 return err
5215 }
5216
5217 if len(t.Evidences) > 8192 {
5218 return xerrors.Errorf("Slice value in field t.Evidences was too long")
5219 }
5220
5221 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Evidences))); err != nil {
5222 return err
5223 }
5224 for _, v := range t.Evidences {
5225 if len(v) > 1000000 {
5226 return xerrors.Errorf("Value in field v was too long")
5227 }
5228
5229 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
5230 return err
5231 }
5232 if _, err := cw.WriteString(string(v)); err != nil {
5233 return err
5234 }
5235
5236 }
5237 }
5238 return nil
5239}
5240
5241func (t *GraphVouch) UnmarshalCBOR(r io.Reader) (err error) {
5242 *t = GraphVouch{}
5243
5244 cr := cbg.NewCborReader(r)
5245
5246 maj, extra, err := cr.ReadHeader()
5247 if err != nil {
5248 return err
5249 }
5250 defer func() {
5251 if err == io.EOF {
5252 err = io.ErrUnexpectedEOF
5253 }
5254 }()
5255
5256 if maj != cbg.MajMap {
5257 return fmt.Errorf("cbor input should be of type map")
5258 }
5259
5260 if extra > cbg.MaxLength {
5261 return fmt.Errorf("GraphVouch: map struct too large (%d)", extra)
5262 }
5263
5264 n := extra
5265
5266 nameBuf := make([]byte, 9)
5267 for i := uint64(0); i < n; i++ {
5268 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5269 if err != nil {
5270 return err
5271 }
5272
5273 if !ok {
5274 // Field doesn't exist on this type, so ignore it
5275 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5276 return err
5277 }
5278 continue
5279 }
5280
5281 switch string(nameBuf[:nameLen]) {
5282 // t.Kind (string) (string)
5283 case "kind":
5284
5285 {
5286 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5287 if err != nil {
5288 return err
5289 }
5290
5291 t.Kind = string(sval)
5292 }
5293 // t.LexiconTypeID (string) (string)
5294 case "$type":
5295
5296 {
5297 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5298 if err != nil {
5299 return err
5300 }
5301
5302 t.LexiconTypeID = string(sval)
5303 }
5304 // t.Reason (string) (string)
5305 case "reason":
5306
5307 {
5308 b, err := cr.ReadByte()
5309 if err != nil {
5310 return err
5311 }
5312 if b != cbg.CborNull[0] {
5313 if err := cr.UnreadByte(); err != nil {
5314 return err
5315 }
5316
5317 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5318 if err != nil {
5319 return err
5320 }
5321
5322 t.Reason = (*string)(&sval)
5323 }
5324 }
5325 // t.CreatedAt (string) (string)
5326 case "createdAt":
5327
5328 {
5329 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5330 if err != nil {
5331 return err
5332 }
5333
5334 t.CreatedAt = string(sval)
5335 }
5336 // t.Evidences ([]string) (slice)
5337 case "evidences":
5338
5339 maj, extra, err = cr.ReadHeader()
5340 if err != nil {
5341 return err
5342 }
5343
5344 if extra > 8192 {
5345 return fmt.Errorf("t.Evidences: array too large (%d)", extra)
5346 }
5347
5348 if maj != cbg.MajArray {
5349 return fmt.Errorf("expected cbor array")
5350 }
5351
5352 if extra > 0 {
5353 t.Evidences = make([]string, extra)
5354 }
5355
5356 for i := 0; i < int(extra); i++ {
5357 {
5358 var maj byte
5359 var extra uint64
5360 var err error
5361 _ = maj
5362 _ = extra
5363 _ = err
5364
5365 {
5366 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5367 if err != nil {
5368 return err
5369 }
5370
5371 t.Evidences[i] = string(sval)
5372 }
5373
5374 }
5375 }
5376
5377 default:
5378 // Field doesn't exist on this type, so ignore it
5379 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5380 return err
5381 }
5382 }
5383 }
5384
5385 return nil
5386}
5387func (t *Knot) MarshalCBOR(w io.Writer) error {
5388 if t == nil {
5389 _, err := w.Write(cbg.CborNull)
5390 return err
5391 }
5392
5393 cw := cbg.NewCborWriter(w)
5394
5395 if _, err := cw.Write([]byte{162}); err != nil {
5396 return err
5397 }
5398
5399 // t.LexiconTypeID (string) (string)
5400 if len("$type") > 1000000 {
5401 return xerrors.Errorf("Value in field \"$type\" was too long")
5402 }
5403
5404 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5405 return err
5406 }
5407 if _, err := cw.WriteString(string("$type")); err != nil {
5408 return err
5409 }
5410
5411 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot"))); err != nil {
5412 return err
5413 }
5414 if _, err := cw.WriteString(string("sh.tangled.knot")); err != nil {
5415 return err
5416 }
5417
5418 // t.CreatedAt (string) (string)
5419 if len("createdAt") > 1000000 {
5420 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5421 }
5422
5423 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5424 return err
5425 }
5426 if _, err := cw.WriteString(string("createdAt")); err != nil {
5427 return err
5428 }
5429
5430 if len(t.CreatedAt) > 1000000 {
5431 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5432 }
5433
5434 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5435 return err
5436 }
5437 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5438 return err
5439 }
5440 return nil
5441}
5442
5443func (t *Knot) UnmarshalCBOR(r io.Reader) (err error) {
5444 *t = Knot{}
5445
5446 cr := cbg.NewCborReader(r)
5447
5448 maj, extra, err := cr.ReadHeader()
5449 if err != nil {
5450 return err
5451 }
5452 defer func() {
5453 if err == io.EOF {
5454 err = io.ErrUnexpectedEOF
5455 }
5456 }()
5457
5458 if maj != cbg.MajMap {
5459 return fmt.Errorf("cbor input should be of type map")
5460 }
5461
5462 if extra > cbg.MaxLength {
5463 return fmt.Errorf("Knot: map struct too large (%d)", extra)
5464 }
5465
5466 n := extra
5467
5468 nameBuf := make([]byte, 9)
5469 for i := uint64(0); i < n; i++ {
5470 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5471 if err != nil {
5472 return err
5473 }
5474
5475 if !ok {
5476 // Field doesn't exist on this type, so ignore it
5477 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5478 return err
5479 }
5480 continue
5481 }
5482
5483 switch string(nameBuf[:nameLen]) {
5484 // t.LexiconTypeID (string) (string)
5485 case "$type":
5486
5487 {
5488 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5489 if err != nil {
5490 return err
5491 }
5492
5493 t.LexiconTypeID = string(sval)
5494 }
5495 // t.CreatedAt (string) (string)
5496 case "createdAt":
5497
5498 {
5499 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5500 if err != nil {
5501 return err
5502 }
5503
5504 t.CreatedAt = string(sval)
5505 }
5506
5507 default:
5508 // Field doesn't exist on this type, so ignore it
5509 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5510 return err
5511 }
5512 }
5513 }
5514
5515 return nil
5516}
5517func (t *KnotMember) MarshalCBOR(w io.Writer) error {
5518 if t == nil {
5519 _, err := w.Write(cbg.CborNull)
5520 return err
5521 }
5522
5523 cw := cbg.NewCborWriter(w)
5524
5525 if _, err := cw.Write([]byte{164}); err != nil {
5526 return err
5527 }
5528
5529 // t.LexiconTypeID (string) (string)
5530 if len("$type") > 1000000 {
5531 return xerrors.Errorf("Value in field \"$type\" was too long")
5532 }
5533
5534 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5535 return err
5536 }
5537 if _, err := cw.WriteString(string("$type")); err != nil {
5538 return err
5539 }
5540
5541 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot.member"))); err != nil {
5542 return err
5543 }
5544 if _, err := cw.WriteString(string("sh.tangled.knot.member")); err != nil {
5545 return err
5546 }
5547
5548 // t.Domain (string) (string)
5549 if len("domain") > 1000000 {
5550 return xerrors.Errorf("Value in field \"domain\" was too long")
5551 }
5552
5553 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("domain"))); err != nil {
5554 return err
5555 }
5556 if _, err := cw.WriteString(string("domain")); err != nil {
5557 return err
5558 }
5559
5560 if len(t.Domain) > 1000000 {
5561 return xerrors.Errorf("Value in field t.Domain was too long")
5562 }
5563
5564 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Domain))); err != nil {
5565 return err
5566 }
5567 if _, err := cw.WriteString(string(t.Domain)); err != nil {
5568 return err
5569 }
5570
5571 // t.Subject (string) (string)
5572 if len("subject") > 1000000 {
5573 return xerrors.Errorf("Value in field \"subject\" was too long")
5574 }
5575
5576 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
5577 return err
5578 }
5579 if _, err := cw.WriteString(string("subject")); err != nil {
5580 return err
5581 }
5582
5583 if len(t.Subject) > 1000000 {
5584 return xerrors.Errorf("Value in field t.Subject was too long")
5585 }
5586
5587 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
5588 return err
5589 }
5590 if _, err := cw.WriteString(string(t.Subject)); err != nil {
5591 return err
5592 }
5593
5594 // t.CreatedAt (string) (string)
5595 if len("createdAt") > 1000000 {
5596 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5597 }
5598
5599 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5600 return err
5601 }
5602 if _, err := cw.WriteString(string("createdAt")); err != nil {
5603 return err
5604 }
5605
5606 if len(t.CreatedAt) > 1000000 {
5607 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5608 }
5609
5610 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5611 return err
5612 }
5613 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5614 return err
5615 }
5616 return nil
5617}
5618
5619func (t *KnotMember) UnmarshalCBOR(r io.Reader) (err error) {
5620 *t = KnotMember{}
5621
5622 cr := cbg.NewCborReader(r)
5623
5624 maj, extra, err := cr.ReadHeader()
5625 if err != nil {
5626 return err
5627 }
5628 defer func() {
5629 if err == io.EOF {
5630 err = io.ErrUnexpectedEOF
5631 }
5632 }()
5633
5634 if maj != cbg.MajMap {
5635 return fmt.Errorf("cbor input should be of type map")
5636 }
5637
5638 if extra > cbg.MaxLength {
5639 return fmt.Errorf("KnotMember: map struct too large (%d)", extra)
5640 }
5641
5642 n := extra
5643
5644 nameBuf := make([]byte, 9)
5645 for i := uint64(0); i < n; i++ {
5646 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5647 if err != nil {
5648 return err
5649 }
5650
5651 if !ok {
5652 // Field doesn't exist on this type, so ignore it
5653 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5654 return err
5655 }
5656 continue
5657 }
5658
5659 switch string(nameBuf[:nameLen]) {
5660 // t.LexiconTypeID (string) (string)
5661 case "$type":
5662
5663 {
5664 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5665 if err != nil {
5666 return err
5667 }
5668
5669 t.LexiconTypeID = string(sval)
5670 }
5671 // t.Domain (string) (string)
5672 case "domain":
5673
5674 {
5675 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5676 if err != nil {
5677 return err
5678 }
5679
5680 t.Domain = string(sval)
5681 }
5682 // t.Subject (string) (string)
5683 case "subject":
5684
5685 {
5686 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5687 if err != nil {
5688 return err
5689 }
5690
5691 t.Subject = string(sval)
5692 }
5693 // t.CreatedAt (string) (string)
5694 case "createdAt":
5695
5696 {
5697 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5698 if err != nil {
5699 return err
5700 }
5701
5702 t.CreatedAt = string(sval)
5703 }
5704
5705 default:
5706 // Field doesn't exist on this type, so ignore it
5707 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5708 return err
5709 }
5710 }
5711 }
5712
5713 return nil
5714}
5715func (t *LabelDefinition) MarshalCBOR(w io.Writer) error {
5716 if t == nil {
5717 _, err := w.Write(cbg.CborNull)
5718 return err
5719 }
5720
5721 cw := cbg.NewCborWriter(w)
5722 fieldCount := 7
5723
5724 if t.Color == nil {
5725 fieldCount--
5726 }
5727
5728 if t.Multiple == nil {
5729 fieldCount--
5730 }
5731
5732 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5733 return err
5734 }
5735
5736 // t.Name (string) (string)
5737 if len("name") > 1000000 {
5738 return xerrors.Errorf("Value in field \"name\" was too long")
5739 }
5740
5741 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5742 return err
5743 }
5744 if _, err := cw.WriteString(string("name")); err != nil {
5745 return err
5746 }
5747
5748 if len(t.Name) > 1000000 {
5749 return xerrors.Errorf("Value in field t.Name was too long")
5750 }
5751
5752 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5753 return err
5754 }
5755 if _, err := cw.WriteString(string(t.Name)); err != nil {
5756 return err
5757 }
5758
5759 // t.LexiconTypeID (string) (string)
5760 if len("$type") > 1000000 {
5761 return xerrors.Errorf("Value in field \"$type\" was too long")
5762 }
5763
5764 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5765 return err
5766 }
5767 if _, err := cw.WriteString(string("$type")); err != nil {
5768 return err
5769 }
5770
5771 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.definition"))); err != nil {
5772 return err
5773 }
5774 if _, err := cw.WriteString(string("sh.tangled.label.definition")); err != nil {
5775 return err
5776 }
5777
5778 // t.Color (string) (string)
5779 if t.Color != nil {
5780
5781 if len("color") > 1000000 {
5782 return xerrors.Errorf("Value in field \"color\" was too long")
5783 }
5784
5785 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("color"))); err != nil {
5786 return err
5787 }
5788 if _, err := cw.WriteString(string("color")); err != nil {
5789 return err
5790 }
5791
5792 if t.Color == nil {
5793 if _, err := cw.Write(cbg.CborNull); err != nil {
5794 return err
5795 }
5796 } else {
5797 if len(*t.Color) > 1000000 {
5798 return xerrors.Errorf("Value in field t.Color was too long")
5799 }
5800
5801 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Color))); err != nil {
5802 return err
5803 }
5804 if _, err := cw.WriteString(string(*t.Color)); err != nil {
5805 return err
5806 }
5807 }
5808 }
5809
5810 // t.Scope ([]string) (slice)
5811 if len("scope") > 1000000 {
5812 return xerrors.Errorf("Value in field \"scope\" was too long")
5813 }
5814
5815 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("scope"))); err != nil {
5816 return err
5817 }
5818 if _, err := cw.WriteString(string("scope")); err != nil {
5819 return err
5820 }
5821
5822 if len(t.Scope) > 8192 {
5823 return xerrors.Errorf("Slice value in field t.Scope was too long")
5824 }
5825
5826 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Scope))); err != nil {
5827 return err
5828 }
5829 for _, v := range t.Scope {
5830 if len(v) > 1000000 {
5831 return xerrors.Errorf("Value in field v was too long")
5832 }
5833
5834 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
5835 return err
5836 }
5837 if _, err := cw.WriteString(string(v)); err != nil {
5838 return err
5839 }
5840
5841 }
5842
5843 // t.Multiple (bool) (bool)
5844 if t.Multiple != nil {
5845
5846 if len("multiple") > 1000000 {
5847 return xerrors.Errorf("Value in field \"multiple\" was too long")
5848 }
5849
5850 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("multiple"))); err != nil {
5851 return err
5852 }
5853 if _, err := cw.WriteString(string("multiple")); err != nil {
5854 return err
5855 }
5856
5857 if t.Multiple == nil {
5858 if _, err := cw.Write(cbg.CborNull); err != nil {
5859 return err
5860 }
5861 } else {
5862 if err := cbg.WriteBool(w, *t.Multiple); err != nil {
5863 return err
5864 }
5865 }
5866 }
5867
5868 // t.CreatedAt (string) (string)
5869 if len("createdAt") > 1000000 {
5870 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5871 }
5872
5873 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5874 return err
5875 }
5876 if _, err := cw.WriteString(string("createdAt")); err != nil {
5877 return err
5878 }
5879
5880 if len(t.CreatedAt) > 1000000 {
5881 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5882 }
5883
5884 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5885 return err
5886 }
5887 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5888 return err
5889 }
5890
5891 // t.ValueType (tangled.LabelDefinition_ValueType) (struct)
5892 if len("valueType") > 1000000 {
5893 return xerrors.Errorf("Value in field \"valueType\" was too long")
5894 }
5895
5896 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("valueType"))); err != nil {
5897 return err
5898 }
5899 if _, err := cw.WriteString(string("valueType")); err != nil {
5900 return err
5901 }
5902
5903 if err := t.ValueType.MarshalCBOR(cw); err != nil {
5904 return err
5905 }
5906 return nil
5907}
5908
5909func (t *LabelDefinition) UnmarshalCBOR(r io.Reader) (err error) {
5910 *t = LabelDefinition{}
5911
5912 cr := cbg.NewCborReader(r)
5913
5914 maj, extra, err := cr.ReadHeader()
5915 if err != nil {
5916 return err
5917 }
5918 defer func() {
5919 if err == io.EOF {
5920 err = io.ErrUnexpectedEOF
5921 }
5922 }()
5923
5924 if maj != cbg.MajMap {
5925 return fmt.Errorf("cbor input should be of type map")
5926 }
5927
5928 if extra > cbg.MaxLength {
5929 return fmt.Errorf("LabelDefinition: map struct too large (%d)", extra)
5930 }
5931
5932 n := extra
5933
5934 nameBuf := make([]byte, 9)
5935 for i := uint64(0); i < n; i++ {
5936 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5937 if err != nil {
5938 return err
5939 }
5940
5941 if !ok {
5942 // Field doesn't exist on this type, so ignore it
5943 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5944 return err
5945 }
5946 continue
5947 }
5948
5949 switch string(nameBuf[:nameLen]) {
5950 // t.Name (string) (string)
5951 case "name":
5952
5953 {
5954 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5955 if err != nil {
5956 return err
5957 }
5958
5959 t.Name = string(sval)
5960 }
5961 // t.LexiconTypeID (string) (string)
5962 case "$type":
5963
5964 {
5965 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5966 if err != nil {
5967 return err
5968 }
5969
5970 t.LexiconTypeID = string(sval)
5971 }
5972 // t.Color (string) (string)
5973 case "color":
5974
5975 {
5976 b, err := cr.ReadByte()
5977 if err != nil {
5978 return err
5979 }
5980 if b != cbg.CborNull[0] {
5981 if err := cr.UnreadByte(); err != nil {
5982 return err
5983 }
5984
5985 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5986 if err != nil {
5987 return err
5988 }
5989
5990 t.Color = (*string)(&sval)
5991 }
5992 }
5993 // t.Scope ([]string) (slice)
5994 case "scope":
5995
5996 maj, extra, err = cr.ReadHeader()
5997 if err != nil {
5998 return err
5999 }
6000
6001 if extra > 8192 {
6002 return fmt.Errorf("t.Scope: array too large (%d)", extra)
6003 }
6004
6005 if maj != cbg.MajArray {
6006 return fmt.Errorf("expected cbor array")
6007 }
6008
6009 if extra > 0 {
6010 t.Scope = make([]string, extra)
6011 }
6012
6013 for i := 0; i < int(extra); i++ {
6014 {
6015 var maj byte
6016 var extra uint64
6017 var err error
6018 _ = maj
6019 _ = extra
6020 _ = err
6021
6022 {
6023 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6024 if err != nil {
6025 return err
6026 }
6027
6028 t.Scope[i] = string(sval)
6029 }
6030
6031 }
6032 }
6033 // t.Multiple (bool) (bool)
6034 case "multiple":
6035
6036 {
6037 b, err := cr.ReadByte()
6038 if err != nil {
6039 return err
6040 }
6041 if b != cbg.CborNull[0] {
6042 if err := cr.UnreadByte(); err != nil {
6043 return err
6044 }
6045
6046 maj, extra, err = cr.ReadHeader()
6047 if err != nil {
6048 return err
6049 }
6050 if maj != cbg.MajOther {
6051 return fmt.Errorf("booleans must be major type 7")
6052 }
6053
6054 var val bool
6055 switch extra {
6056 case 20:
6057 val = false
6058 case 21:
6059 val = true
6060 default:
6061 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
6062 }
6063 t.Multiple = &val
6064 }
6065 }
6066 // t.CreatedAt (string) (string)
6067 case "createdAt":
6068
6069 {
6070 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6071 if err != nil {
6072 return err
6073 }
6074
6075 t.CreatedAt = string(sval)
6076 }
6077 // t.ValueType (tangled.LabelDefinition_ValueType) (struct)
6078 case "valueType":
6079
6080 {
6081
6082 b, err := cr.ReadByte()
6083 if err != nil {
6084 return err
6085 }
6086 if b != cbg.CborNull[0] {
6087 if err := cr.UnreadByte(); err != nil {
6088 return err
6089 }
6090 t.ValueType = new(LabelDefinition_ValueType)
6091 if err := t.ValueType.UnmarshalCBOR(cr); err != nil {
6092 return xerrors.Errorf("unmarshaling t.ValueType pointer: %w", err)
6093 }
6094 }
6095
6096 }
6097
6098 default:
6099 // Field doesn't exist on this type, so ignore it
6100 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6101 return err
6102 }
6103 }
6104 }
6105
6106 return nil
6107}
6108func (t *LabelDefinition_ValueType) MarshalCBOR(w io.Writer) error {
6109 if t == nil {
6110 _, err := w.Write(cbg.CborNull)
6111 return err
6112 }
6113
6114 cw := cbg.NewCborWriter(w)
6115 fieldCount := 3
6116
6117 if t.Enum == nil {
6118 fieldCount--
6119 }
6120
6121 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6122 return err
6123 }
6124
6125 // t.Enum ([]string) (slice)
6126 if t.Enum != nil {
6127
6128 if len("enum") > 1000000 {
6129 return xerrors.Errorf("Value in field \"enum\" was too long")
6130 }
6131
6132 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("enum"))); err != nil {
6133 return err
6134 }
6135 if _, err := cw.WriteString(string("enum")); err != nil {
6136 return err
6137 }
6138
6139 if len(t.Enum) > 8192 {
6140 return xerrors.Errorf("Slice value in field t.Enum was too long")
6141 }
6142
6143 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Enum))); err != nil {
6144 return err
6145 }
6146 for _, v := range t.Enum {
6147 if len(v) > 1000000 {
6148 return xerrors.Errorf("Value in field v was too long")
6149 }
6150
6151 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
6152 return err
6153 }
6154 if _, err := cw.WriteString(string(v)); err != nil {
6155 return err
6156 }
6157
6158 }
6159 }
6160
6161 // t.Type (string) (string)
6162 if len("type") > 1000000 {
6163 return xerrors.Errorf("Value in field \"type\" was too long")
6164 }
6165
6166 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("type"))); err != nil {
6167 return err
6168 }
6169 if _, err := cw.WriteString(string("type")); err != nil {
6170 return err
6171 }
6172
6173 if len(t.Type) > 1000000 {
6174 return xerrors.Errorf("Value in field t.Type was too long")
6175 }
6176
6177 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Type))); err != nil {
6178 return err
6179 }
6180 if _, err := cw.WriteString(string(t.Type)); err != nil {
6181 return err
6182 }
6183
6184 // t.Format (string) (string)
6185 if len("format") > 1000000 {
6186 return xerrors.Errorf("Value in field \"format\" was too long")
6187 }
6188
6189 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("format"))); err != nil {
6190 return err
6191 }
6192 if _, err := cw.WriteString(string("format")); err != nil {
6193 return err
6194 }
6195
6196 if len(t.Format) > 1000000 {
6197 return xerrors.Errorf("Value in field t.Format was too long")
6198 }
6199
6200 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Format))); err != nil {
6201 return err
6202 }
6203 if _, err := cw.WriteString(string(t.Format)); err != nil {
6204 return err
6205 }
6206 return nil
6207}
6208
6209func (t *LabelDefinition_ValueType) UnmarshalCBOR(r io.Reader) (err error) {
6210 *t = LabelDefinition_ValueType{}
6211
6212 cr := cbg.NewCborReader(r)
6213
6214 maj, extra, err := cr.ReadHeader()
6215 if err != nil {
6216 return err
6217 }
6218 defer func() {
6219 if err == io.EOF {
6220 err = io.ErrUnexpectedEOF
6221 }
6222 }()
6223
6224 if maj != cbg.MajMap {
6225 return fmt.Errorf("cbor input should be of type map")
6226 }
6227
6228 if extra > cbg.MaxLength {
6229 return fmt.Errorf("LabelDefinition_ValueType: map struct too large (%d)", extra)
6230 }
6231
6232 n := extra
6233
6234 nameBuf := make([]byte, 6)
6235 for i := uint64(0); i < n; i++ {
6236 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6237 if err != nil {
6238 return err
6239 }
6240
6241 if !ok {
6242 // Field doesn't exist on this type, so ignore it
6243 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6244 return err
6245 }
6246 continue
6247 }
6248
6249 switch string(nameBuf[:nameLen]) {
6250 // t.Enum ([]string) (slice)
6251 case "enum":
6252
6253 maj, extra, err = cr.ReadHeader()
6254 if err != nil {
6255 return err
6256 }
6257
6258 if extra > 8192 {
6259 return fmt.Errorf("t.Enum: array too large (%d)", extra)
6260 }
6261
6262 if maj != cbg.MajArray {
6263 return fmt.Errorf("expected cbor array")
6264 }
6265
6266 if extra > 0 {
6267 t.Enum = make([]string, extra)
6268 }
6269
6270 for i := 0; i < int(extra); i++ {
6271 {
6272 var maj byte
6273 var extra uint64
6274 var err error
6275 _ = maj
6276 _ = extra
6277 _ = err
6278
6279 {
6280 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6281 if err != nil {
6282 return err
6283 }
6284
6285 t.Enum[i] = string(sval)
6286 }
6287
6288 }
6289 }
6290 // t.Type (string) (string)
6291 case "type":
6292
6293 {
6294 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6295 if err != nil {
6296 return err
6297 }
6298
6299 t.Type = string(sval)
6300 }
6301 // t.Format (string) (string)
6302 case "format":
6303
6304 {
6305 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6306 if err != nil {
6307 return err
6308 }
6309
6310 t.Format = string(sval)
6311 }
6312
6313 default:
6314 // Field doesn't exist on this type, so ignore it
6315 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6316 return err
6317 }
6318 }
6319 }
6320
6321 return nil
6322}
6323func (t *LabelOp) MarshalCBOR(w io.Writer) error {
6324 if t == nil {
6325 _, err := w.Write(cbg.CborNull)
6326 return err
6327 }
6328
6329 cw := cbg.NewCborWriter(w)
6330
6331 if _, err := cw.Write([]byte{165}); err != nil {
6332 return err
6333 }
6334
6335 // t.Add ([]*tangled.LabelOp_Operand) (slice)
6336 if len("add") > 1000000 {
6337 return xerrors.Errorf("Value in field \"add\" was too long")
6338 }
6339
6340 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("add"))); err != nil {
6341 return err
6342 }
6343 if _, err := cw.WriteString(string("add")); err != nil {
6344 return err
6345 }
6346
6347 if len(t.Add) > 8192 {
6348 return xerrors.Errorf("Slice value in field t.Add was too long")
6349 }
6350
6351 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Add))); err != nil {
6352 return err
6353 }
6354 for _, v := range t.Add {
6355 if err := v.MarshalCBOR(cw); err != nil {
6356 return err
6357 }
6358
6359 }
6360
6361 // t.LexiconTypeID (string) (string)
6362 if len("$type") > 1000000 {
6363 return xerrors.Errorf("Value in field \"$type\" was too long")
6364 }
6365
6366 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6367 return err
6368 }
6369 if _, err := cw.WriteString(string("$type")); err != nil {
6370 return err
6371 }
6372
6373 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.op"))); err != nil {
6374 return err
6375 }
6376 if _, err := cw.WriteString(string("sh.tangled.label.op")); err != nil {
6377 return err
6378 }
6379
6380 // t.Delete ([]*tangled.LabelOp_Operand) (slice)
6381 if len("delete") > 1000000 {
6382 return xerrors.Errorf("Value in field \"delete\" was too long")
6383 }
6384
6385 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("delete"))); err != nil {
6386 return err
6387 }
6388 if _, err := cw.WriteString(string("delete")); err != nil {
6389 return err
6390 }
6391
6392 if len(t.Delete) > 8192 {
6393 return xerrors.Errorf("Slice value in field t.Delete was too long")
6394 }
6395
6396 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Delete))); err != nil {
6397 return err
6398 }
6399 for _, v := range t.Delete {
6400 if err := v.MarshalCBOR(cw); err != nil {
6401 return err
6402 }
6403
6404 }
6405
6406 // t.Subject (string) (string)
6407 if len("subject") > 1000000 {
6408 return xerrors.Errorf("Value in field \"subject\" was too long")
6409 }
6410
6411 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
6412 return err
6413 }
6414 if _, err := cw.WriteString(string("subject")); err != nil {
6415 return err
6416 }
6417
6418 if len(t.Subject) > 1000000 {
6419 return xerrors.Errorf("Value in field t.Subject was too long")
6420 }
6421
6422 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
6423 return err
6424 }
6425 if _, err := cw.WriteString(string(t.Subject)); err != nil {
6426 return err
6427 }
6428
6429 // t.PerformedAt (string) (string)
6430 if len("performedAt") > 1000000 {
6431 return xerrors.Errorf("Value in field \"performedAt\" was too long")
6432 }
6433
6434 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("performedAt"))); err != nil {
6435 return err
6436 }
6437 if _, err := cw.WriteString(string("performedAt")); err != nil {
6438 return err
6439 }
6440
6441 if len(t.PerformedAt) > 1000000 {
6442 return xerrors.Errorf("Value in field t.PerformedAt was too long")
6443 }
6444
6445 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.PerformedAt))); err != nil {
6446 return err
6447 }
6448 if _, err := cw.WriteString(string(t.PerformedAt)); err != nil {
6449 return err
6450 }
6451 return nil
6452}
6453
6454func (t *LabelOp) UnmarshalCBOR(r io.Reader) (err error) {
6455 *t = LabelOp{}
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("LabelOp: map struct too large (%d)", extra)
6475 }
6476
6477 n := extra
6478
6479 nameBuf := make([]byte, 11)
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.Add ([]*tangled.LabelOp_Operand) (slice)
6496 case "add":
6497
6498 maj, extra, err = cr.ReadHeader()
6499 if err != nil {
6500 return err
6501 }
6502
6503 if extra > 8192 {
6504 return fmt.Errorf("t.Add: array too large (%d)", extra)
6505 }
6506
6507 if maj != cbg.MajArray {
6508 return fmt.Errorf("expected cbor array")
6509 }
6510
6511 if extra > 0 {
6512 t.Add = make([]*LabelOp_Operand, extra)
6513 }
6514
6515 for i := 0; i < int(extra); i++ {
6516 {
6517 var maj byte
6518 var extra uint64
6519 var err error
6520 _ = maj
6521 _ = extra
6522 _ = err
6523
6524 {
6525
6526 b, err := cr.ReadByte()
6527 if err != nil {
6528 return err
6529 }
6530 if b != cbg.CborNull[0] {
6531 if err := cr.UnreadByte(); err != nil {
6532 return err
6533 }
6534 t.Add[i] = new(LabelOp_Operand)
6535 if err := t.Add[i].UnmarshalCBOR(cr); err != nil {
6536 return xerrors.Errorf("unmarshaling t.Add[i] pointer: %w", err)
6537 }
6538 }
6539
6540 }
6541
6542 }
6543 }
6544 // t.LexiconTypeID (string) (string)
6545 case "$type":
6546
6547 {
6548 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6549 if err != nil {
6550 return err
6551 }
6552
6553 t.LexiconTypeID = string(sval)
6554 }
6555 // t.Delete ([]*tangled.LabelOp_Operand) (slice)
6556 case "delete":
6557
6558 maj, extra, err = cr.ReadHeader()
6559 if err != nil {
6560 return err
6561 }
6562
6563 if extra > 8192 {
6564 return fmt.Errorf("t.Delete: array too large (%d)", extra)
6565 }
6566
6567 if maj != cbg.MajArray {
6568 return fmt.Errorf("expected cbor array")
6569 }
6570
6571 if extra > 0 {
6572 t.Delete = make([]*LabelOp_Operand, extra)
6573 }
6574
6575 for i := 0; i < int(extra); i++ {
6576 {
6577 var maj byte
6578 var extra uint64
6579 var err error
6580 _ = maj
6581 _ = extra
6582 _ = err
6583
6584 {
6585
6586 b, err := cr.ReadByte()
6587 if err != nil {
6588 return err
6589 }
6590 if b != cbg.CborNull[0] {
6591 if err := cr.UnreadByte(); err != nil {
6592 return err
6593 }
6594 t.Delete[i] = new(LabelOp_Operand)
6595 if err := t.Delete[i].UnmarshalCBOR(cr); err != nil {
6596 return xerrors.Errorf("unmarshaling t.Delete[i] pointer: %w", err)
6597 }
6598 }
6599
6600 }
6601
6602 }
6603 }
6604 // t.Subject (string) (string)
6605 case "subject":
6606
6607 {
6608 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6609 if err != nil {
6610 return err
6611 }
6612
6613 t.Subject = string(sval)
6614 }
6615 // t.PerformedAt (string) (string)
6616 case "performedAt":
6617
6618 {
6619 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6620 if err != nil {
6621 return err
6622 }
6623
6624 t.PerformedAt = string(sval)
6625 }
6626
6627 default:
6628 // Field doesn't exist on this type, so ignore it
6629 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6630 return err
6631 }
6632 }
6633 }
6634
6635 return nil
6636}
6637func (t *LabelOp_Operand) MarshalCBOR(w io.Writer) error {
6638 if t == nil {
6639 _, err := w.Write(cbg.CborNull)
6640 return err
6641 }
6642
6643 cw := cbg.NewCborWriter(w)
6644
6645 if _, err := cw.Write([]byte{162}); err != nil {
6646 return err
6647 }
6648
6649 // t.Key (string) (string)
6650 if len("key") > 1000000 {
6651 return xerrors.Errorf("Value in field \"key\" was too long")
6652 }
6653
6654 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
6655 return err
6656 }
6657 if _, err := cw.WriteString(string("key")); err != nil {
6658 return err
6659 }
6660
6661 if len(t.Key) > 1000000 {
6662 return xerrors.Errorf("Value in field t.Key was too long")
6663 }
6664
6665 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
6666 return err
6667 }
6668 if _, err := cw.WriteString(string(t.Key)); err != nil {
6669 return err
6670 }
6671
6672 // t.Value (string) (string)
6673 if len("value") > 1000000 {
6674 return xerrors.Errorf("Value in field \"value\" was too long")
6675 }
6676
6677 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
6678 return err
6679 }
6680 if _, err := cw.WriteString(string("value")); err != nil {
6681 return err
6682 }
6683
6684 if len(t.Value) > 1000000 {
6685 return xerrors.Errorf("Value in field t.Value was too long")
6686 }
6687
6688 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
6689 return err
6690 }
6691 if _, err := cw.WriteString(string(t.Value)); err != nil {
6692 return err
6693 }
6694 return nil
6695}
6696
6697func (t *LabelOp_Operand) UnmarshalCBOR(r io.Reader) (err error) {
6698 *t = LabelOp_Operand{}
6699
6700 cr := cbg.NewCborReader(r)
6701
6702 maj, extra, err := cr.ReadHeader()
6703 if err != nil {
6704 return err
6705 }
6706 defer func() {
6707 if err == io.EOF {
6708 err = io.ErrUnexpectedEOF
6709 }
6710 }()
6711
6712 if maj != cbg.MajMap {
6713 return fmt.Errorf("cbor input should be of type map")
6714 }
6715
6716 if extra > cbg.MaxLength {
6717 return fmt.Errorf("LabelOp_Operand: map struct too large (%d)", extra)
6718 }
6719
6720 n := extra
6721
6722 nameBuf := make([]byte, 5)
6723 for i := uint64(0); i < n; i++ {
6724 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6725 if err != nil {
6726 return err
6727 }
6728
6729 if !ok {
6730 // Field doesn't exist on this type, so ignore it
6731 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6732 return err
6733 }
6734 continue
6735 }
6736
6737 switch string(nameBuf[:nameLen]) {
6738 // t.Key (string) (string)
6739 case "key":
6740
6741 {
6742 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6743 if err != nil {
6744 return err
6745 }
6746
6747 t.Key = string(sval)
6748 }
6749 // t.Value (string) (string)
6750 case "value":
6751
6752 {
6753 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6754 if err != nil {
6755 return err
6756 }
6757
6758 t.Value = string(sval)
6759 }
6760
6761 default:
6762 // Field doesn't exist on this type, so ignore it
6763 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6764 return err
6765 }
6766 }
6767 }
6768
6769 return nil
6770}
6771func (t *MarkupMarkdown) MarshalCBOR(w io.Writer) error {
6772 if t == nil {
6773 _, err := w.Write(cbg.CborNull)
6774 return err
6775 }
6776
6777 cw := cbg.NewCborWriter(w)
6778 fieldCount := 4
6779
6780 if t.Blobs == nil {
6781 fieldCount--
6782 }
6783
6784 if t.Original == nil {
6785 fieldCount--
6786 }
6787
6788 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6789 return err
6790 }
6791
6792 // t.Text (string) (string)
6793 if len("text") > 1000000 {
6794 return xerrors.Errorf("Value in field \"text\" was too long")
6795 }
6796
6797 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("text"))); err != nil {
6798 return err
6799 }
6800 if _, err := cw.WriteString(string("text")); err != nil {
6801 return err
6802 }
6803
6804 if len(t.Text) > 1000000 {
6805 return xerrors.Errorf("Value in field t.Text was too long")
6806 }
6807
6808 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Text))); err != nil {
6809 return err
6810 }
6811 if _, err := cw.WriteString(string(t.Text)); err != nil {
6812 return err
6813 }
6814
6815 // t.LexiconTypeID (string) (string)
6816 if len("$type") > 1000000 {
6817 return xerrors.Errorf("Value in field \"$type\" was too long")
6818 }
6819
6820 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6821 return err
6822 }
6823 if _, err := cw.WriteString(string("$type")); err != nil {
6824 return err
6825 }
6826
6827 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.markup.markdown"))); err != nil {
6828 return err
6829 }
6830 if _, err := cw.WriteString(string("sh.tangled.markup.markdown")); err != nil {
6831 return err
6832 }
6833
6834 // t.Blobs ([]*util.LexBlob) (slice)
6835 if t.Blobs != nil {
6836
6837 if len("blobs") > 1000000 {
6838 return xerrors.Errorf("Value in field \"blobs\" was too long")
6839 }
6840
6841 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("blobs"))); err != nil {
6842 return err
6843 }
6844 if _, err := cw.WriteString(string("blobs")); err != nil {
6845 return err
6846 }
6847
6848 if len(t.Blobs) > 8192 {
6849 return xerrors.Errorf("Slice value in field t.Blobs was too long")
6850 }
6851
6852 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Blobs))); err != nil {
6853 return err
6854 }
6855 for _, v := range t.Blobs {
6856 if err := v.MarshalCBOR(cw); err != nil {
6857 return err
6858 }
6859
6860 }
6861 }
6862
6863 // t.Original (string) (string)
6864 if t.Original != nil {
6865
6866 if len("original") > 1000000 {
6867 return xerrors.Errorf("Value in field \"original\" was too long")
6868 }
6869
6870 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("original"))); err != nil {
6871 return err
6872 }
6873 if _, err := cw.WriteString(string("original")); err != nil {
6874 return err
6875 }
6876
6877 if t.Original == nil {
6878 if _, err := cw.Write(cbg.CborNull); err != nil {
6879 return err
6880 }
6881 } else {
6882 if len(*t.Original) > 1000000 {
6883 return xerrors.Errorf("Value in field t.Original was too long")
6884 }
6885
6886 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Original))); err != nil {
6887 return err
6888 }
6889 if _, err := cw.WriteString(string(*t.Original)); err != nil {
6890 return err
6891 }
6892 }
6893 }
6894 return nil
6895}
6896
6897func (t *MarkupMarkdown) UnmarshalCBOR(r io.Reader) (err error) {
6898 *t = MarkupMarkdown{}
6899
6900 cr := cbg.NewCborReader(r)
6901
6902 maj, extra, err := cr.ReadHeader()
6903 if err != nil {
6904 return err
6905 }
6906 defer func() {
6907 if err == io.EOF {
6908 err = io.ErrUnexpectedEOF
6909 }
6910 }()
6911
6912 if maj != cbg.MajMap {
6913 return fmt.Errorf("cbor input should be of type map")
6914 }
6915
6916 if extra > cbg.MaxLength {
6917 return fmt.Errorf("MarkupMarkdown: map struct too large (%d)", extra)
6918 }
6919
6920 n := extra
6921
6922 nameBuf := make([]byte, 8)
6923 for i := uint64(0); i < n; i++ {
6924 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6925 if err != nil {
6926 return err
6927 }
6928
6929 if !ok {
6930 // Field doesn't exist on this type, so ignore it
6931 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6932 return err
6933 }
6934 continue
6935 }
6936
6937 switch string(nameBuf[:nameLen]) {
6938 // t.Text (string) (string)
6939 case "text":
6940
6941 {
6942 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6943 if err != nil {
6944 return err
6945 }
6946
6947 t.Text = string(sval)
6948 }
6949 // t.LexiconTypeID (string) (string)
6950 case "$type":
6951
6952 {
6953 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6954 if err != nil {
6955 return err
6956 }
6957
6958 t.LexiconTypeID = string(sval)
6959 }
6960 // t.Blobs ([]*util.LexBlob) (slice)
6961 case "blobs":
6962
6963 maj, extra, err = cr.ReadHeader()
6964 if err != nil {
6965 return err
6966 }
6967
6968 if extra > 8192 {
6969 return fmt.Errorf("t.Blobs: array too large (%d)", extra)
6970 }
6971
6972 if maj != cbg.MajArray {
6973 return fmt.Errorf("expected cbor array")
6974 }
6975
6976 if extra > 0 {
6977 t.Blobs = make([]*util.LexBlob, extra)
6978 }
6979
6980 for i := 0; i < int(extra); i++ {
6981 {
6982 var maj byte
6983 var extra uint64
6984 var err error
6985 _ = maj
6986 _ = extra
6987 _ = err
6988
6989 {
6990
6991 b, err := cr.ReadByte()
6992 if err != nil {
6993 return err
6994 }
6995 if b != cbg.CborNull[0] {
6996 if err := cr.UnreadByte(); err != nil {
6997 return err
6998 }
6999 t.Blobs[i] = new(util.LexBlob)
7000 if err := t.Blobs[i].UnmarshalCBOR(cr); err != nil {
7001 return xerrors.Errorf("unmarshaling t.Blobs[i] pointer: %w", err)
7002 }
7003 }
7004
7005 }
7006
7007 }
7008 }
7009 // t.Original (string) (string)
7010 case "original":
7011
7012 {
7013 b, err := cr.ReadByte()
7014 if err != nil {
7015 return err
7016 }
7017 if b != cbg.CborNull[0] {
7018 if err := cr.UnreadByte(); err != nil {
7019 return err
7020 }
7021
7022 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7023 if err != nil {
7024 return err
7025 }
7026
7027 t.Original = (*string)(&sval)
7028 }
7029 }
7030
7031 default:
7032 // Field doesn't exist on this type, so ignore it
7033 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7034 return err
7035 }
7036 }
7037 }
7038
7039 return nil
7040}
7041func (t *Pipeline) MarshalCBOR(w io.Writer) error {
7042 if t == nil {
7043 _, err := w.Write(cbg.CborNull)
7044 return err
7045 }
7046
7047 cw := cbg.NewCborWriter(w)
7048
7049 if _, err := cw.Write([]byte{163}); err != nil {
7050 return err
7051 }
7052
7053 // t.LexiconTypeID (string) (string)
7054 if len("$type") > 1000000 {
7055 return xerrors.Errorf("Value in field \"$type\" was too long")
7056 }
7057
7058 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7059 return err
7060 }
7061 if _, err := cw.WriteString(string("$type")); err != nil {
7062 return err
7063 }
7064
7065 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil {
7066 return err
7067 }
7068 if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil {
7069 return err
7070 }
7071
7072 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
7073 if len("workflows") > 1000000 {
7074 return xerrors.Errorf("Value in field \"workflows\" was too long")
7075 }
7076
7077 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil {
7078 return err
7079 }
7080 if _, err := cw.WriteString(string("workflows")); err != nil {
7081 return err
7082 }
7083
7084 if len(t.Workflows) > 8192 {
7085 return xerrors.Errorf("Slice value in field t.Workflows was too long")
7086 }
7087
7088 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil {
7089 return err
7090 }
7091 for _, v := range t.Workflows {
7092 if err := v.MarshalCBOR(cw); err != nil {
7093 return err
7094 }
7095
7096 }
7097
7098 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
7099 if len("triggerMetadata") > 1000000 {
7100 return xerrors.Errorf("Value in field \"triggerMetadata\" was too long")
7101 }
7102
7103 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil {
7104 return err
7105 }
7106 if _, err := cw.WriteString(string("triggerMetadata")); err != nil {
7107 return err
7108 }
7109
7110 if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil {
7111 return err
7112 }
7113 return nil
7114}
7115
7116func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) {
7117 *t = Pipeline{}
7118
7119 cr := cbg.NewCborReader(r)
7120
7121 maj, extra, err := cr.ReadHeader()
7122 if err != nil {
7123 return err
7124 }
7125 defer func() {
7126 if err == io.EOF {
7127 err = io.ErrUnexpectedEOF
7128 }
7129 }()
7130
7131 if maj != cbg.MajMap {
7132 return fmt.Errorf("cbor input should be of type map")
7133 }
7134
7135 if extra > cbg.MaxLength {
7136 return fmt.Errorf("Pipeline: map struct too large (%d)", extra)
7137 }
7138
7139 n := extra
7140
7141 nameBuf := make([]byte, 15)
7142 for i := uint64(0); i < n; i++ {
7143 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7144 if err != nil {
7145 return err
7146 }
7147
7148 if !ok {
7149 // Field doesn't exist on this type, so ignore it
7150 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7151 return err
7152 }
7153 continue
7154 }
7155
7156 switch string(nameBuf[:nameLen]) {
7157 // t.LexiconTypeID (string) (string)
7158 case "$type":
7159
7160 {
7161 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7162 if err != nil {
7163 return err
7164 }
7165
7166 t.LexiconTypeID = string(sval)
7167 }
7168 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
7169 case "workflows":
7170
7171 maj, extra, err = cr.ReadHeader()
7172 if err != nil {
7173 return err
7174 }
7175
7176 if extra > 8192 {
7177 return fmt.Errorf("t.Workflows: array too large (%d)", extra)
7178 }
7179
7180 if maj != cbg.MajArray {
7181 return fmt.Errorf("expected cbor array")
7182 }
7183
7184 if extra > 0 {
7185 t.Workflows = make([]*Pipeline_Workflow, extra)
7186 }
7187
7188 for i := 0; i < int(extra); i++ {
7189 {
7190 var maj byte
7191 var extra uint64
7192 var err error
7193 _ = maj
7194 _ = extra
7195 _ = err
7196
7197 {
7198
7199 b, err := cr.ReadByte()
7200 if err != nil {
7201 return err
7202 }
7203 if b != cbg.CborNull[0] {
7204 if err := cr.UnreadByte(); err != nil {
7205 return err
7206 }
7207 t.Workflows[i] = new(Pipeline_Workflow)
7208 if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil {
7209 return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err)
7210 }
7211 }
7212
7213 }
7214
7215 }
7216 }
7217 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
7218 case "triggerMetadata":
7219
7220 {
7221
7222 b, err := cr.ReadByte()
7223 if err != nil {
7224 return err
7225 }
7226 if b != cbg.CborNull[0] {
7227 if err := cr.UnreadByte(); err != nil {
7228 return err
7229 }
7230 t.TriggerMetadata = new(Pipeline_TriggerMetadata)
7231 if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil {
7232 return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err)
7233 }
7234 }
7235
7236 }
7237
7238 default:
7239 // Field doesn't exist on this type, so ignore it
7240 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7241 return err
7242 }
7243 }
7244 }
7245
7246 return nil
7247}
7248func (t *Pipeline_CloneOpts) MarshalCBOR(w io.Writer) error {
7249 if t == nil {
7250 _, err := w.Write(cbg.CborNull)
7251 return err
7252 }
7253
7254 cw := cbg.NewCborWriter(w)
7255
7256 if _, err := cw.Write([]byte{164}); err != nil {
7257 return err
7258 }
7259
7260 // t.Skip (bool) (bool)
7261 if len("skip") > 1000000 {
7262 return xerrors.Errorf("Value in field \"skip\" was too long")
7263 }
7264
7265 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("skip"))); err != nil {
7266 return err
7267 }
7268 if _, err := cw.WriteString(string("skip")); err != nil {
7269 return err
7270 }
7271
7272 if err := cbg.WriteBool(w, t.Skip); err != nil {
7273 return err
7274 }
7275
7276 // t.Tags (bool) (bool)
7277 if len("tags") > 1000000 {
7278 return xerrors.Errorf("Value in field \"tags\" was too long")
7279 }
7280
7281 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tags"))); err != nil {
7282 return err
7283 }
7284 if _, err := cw.WriteString(string("tags")); err != nil {
7285 return err
7286 }
7287
7288 if err := cbg.WriteBool(w, t.Tags); err != nil {
7289 return err
7290 }
7291
7292 // t.Depth (int64) (int64)
7293 if len("depth") > 1000000 {
7294 return xerrors.Errorf("Value in field \"depth\" was too long")
7295 }
7296
7297 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("depth"))); err != nil {
7298 return err
7299 }
7300 if _, err := cw.WriteString(string("depth")); err != nil {
7301 return err
7302 }
7303
7304 if t.Depth >= 0 {
7305 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Depth)); err != nil {
7306 return err
7307 }
7308 } else {
7309 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Depth-1)); err != nil {
7310 return err
7311 }
7312 }
7313
7314 // t.Submodules (bool) (bool)
7315 if len("submodules") > 1000000 {
7316 return xerrors.Errorf("Value in field \"submodules\" was too long")
7317 }
7318
7319 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("submodules"))); err != nil {
7320 return err
7321 }
7322 if _, err := cw.WriteString(string("submodules")); err != nil {
7323 return err
7324 }
7325
7326 if err := cbg.WriteBool(w, t.Submodules); err != nil {
7327 return err
7328 }
7329 return nil
7330}
7331
7332func (t *Pipeline_CloneOpts) UnmarshalCBOR(r io.Reader) (err error) {
7333 *t = Pipeline_CloneOpts{}
7334
7335 cr := cbg.NewCborReader(r)
7336
7337 maj, extra, err := cr.ReadHeader()
7338 if err != nil {
7339 return err
7340 }
7341 defer func() {
7342 if err == io.EOF {
7343 err = io.ErrUnexpectedEOF
7344 }
7345 }()
7346
7347 if maj != cbg.MajMap {
7348 return fmt.Errorf("cbor input should be of type map")
7349 }
7350
7351 if extra > cbg.MaxLength {
7352 return fmt.Errorf("Pipeline_CloneOpts: map struct too large (%d)", extra)
7353 }
7354
7355 n := extra
7356
7357 nameBuf := make([]byte, 10)
7358 for i := uint64(0); i < n; i++ {
7359 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7360 if err != nil {
7361 return err
7362 }
7363
7364 if !ok {
7365 // Field doesn't exist on this type, so ignore it
7366 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7367 return err
7368 }
7369 continue
7370 }
7371
7372 switch string(nameBuf[:nameLen]) {
7373 // t.Skip (bool) (bool)
7374 case "skip":
7375
7376 maj, extra, err = cr.ReadHeader()
7377 if err != nil {
7378 return err
7379 }
7380 if maj != cbg.MajOther {
7381 return fmt.Errorf("booleans must be major type 7")
7382 }
7383 switch extra {
7384 case 20:
7385 t.Skip = false
7386 case 21:
7387 t.Skip = true
7388 default:
7389 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
7390 }
7391 // t.Tags (bool) (bool)
7392 case "tags":
7393
7394 maj, extra, err = cr.ReadHeader()
7395 if err != nil {
7396 return err
7397 }
7398 if maj != cbg.MajOther {
7399 return fmt.Errorf("booleans must be major type 7")
7400 }
7401 switch extra {
7402 case 20:
7403 t.Tags = false
7404 case 21:
7405 t.Tags = true
7406 default:
7407 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
7408 }
7409 // t.Depth (int64) (int64)
7410 case "depth":
7411 {
7412 maj, extra, err := cr.ReadHeader()
7413 if err != nil {
7414 return err
7415 }
7416 var extraI int64
7417 switch maj {
7418 case cbg.MajUnsignedInt:
7419 extraI = int64(extra)
7420 if extraI < 0 {
7421 return fmt.Errorf("int64 positive overflow")
7422 }
7423 case cbg.MajNegativeInt:
7424 extraI = int64(extra)
7425 if extraI < 0 {
7426 return fmt.Errorf("int64 negative overflow")
7427 }
7428 extraI = -1 - extraI
7429 default:
7430 return fmt.Errorf("wrong type for int64 field: %d", maj)
7431 }
7432
7433 t.Depth = int64(extraI)
7434 }
7435 // t.Submodules (bool) (bool)
7436 case "submodules":
7437
7438 maj, extra, err = cr.ReadHeader()
7439 if err != nil {
7440 return err
7441 }
7442 if maj != cbg.MajOther {
7443 return fmt.Errorf("booleans must be major type 7")
7444 }
7445 switch extra {
7446 case 20:
7447 t.Submodules = false
7448 case 21:
7449 t.Submodules = true
7450 default:
7451 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
7452 }
7453
7454 default:
7455 // Field doesn't exist on this type, so ignore it
7456 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7457 return err
7458 }
7459 }
7460 }
7461
7462 return nil
7463}
7464func (t *Pipeline_ManualTriggerData) MarshalCBOR(w io.Writer) error {
7465 if t == nil {
7466 _, err := w.Write(cbg.CborNull)
7467 return err
7468 }
7469
7470 cw := cbg.NewCborWriter(w)
7471 fieldCount := 1
7472
7473 if t.Inputs == nil {
7474 fieldCount--
7475 }
7476
7477 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7478 return err
7479 }
7480
7481 // t.Inputs ([]*tangled.Pipeline_Pair) (slice)
7482 if t.Inputs != nil {
7483
7484 if len("inputs") > 1000000 {
7485 return xerrors.Errorf("Value in field \"inputs\" was too long")
7486 }
7487
7488 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
7489 return err
7490 }
7491 if _, err := cw.WriteString(string("inputs")); err != nil {
7492 return err
7493 }
7494
7495 if len(t.Inputs) > 8192 {
7496 return xerrors.Errorf("Slice value in field t.Inputs was too long")
7497 }
7498
7499 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
7500 return err
7501 }
7502 for _, v := range t.Inputs {
7503 if err := v.MarshalCBOR(cw); err != nil {
7504 return err
7505 }
7506
7507 }
7508 }
7509 return nil
7510}
7511
7512func (t *Pipeline_ManualTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
7513 *t = Pipeline_ManualTriggerData{}
7514
7515 cr := cbg.NewCborReader(r)
7516
7517 maj, extra, err := cr.ReadHeader()
7518 if err != nil {
7519 return err
7520 }
7521 defer func() {
7522 if err == io.EOF {
7523 err = io.ErrUnexpectedEOF
7524 }
7525 }()
7526
7527 if maj != cbg.MajMap {
7528 return fmt.Errorf("cbor input should be of type map")
7529 }
7530
7531 if extra > cbg.MaxLength {
7532 return fmt.Errorf("Pipeline_ManualTriggerData: map struct too large (%d)", extra)
7533 }
7534
7535 n := extra
7536
7537 nameBuf := make([]byte, 6)
7538 for i := uint64(0); i < n; i++ {
7539 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7540 if err != nil {
7541 return err
7542 }
7543
7544 if !ok {
7545 // Field doesn't exist on this type, so ignore it
7546 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7547 return err
7548 }
7549 continue
7550 }
7551
7552 switch string(nameBuf[:nameLen]) {
7553 // t.Inputs ([]*tangled.Pipeline_Pair) (slice)
7554 case "inputs":
7555
7556 maj, extra, err = cr.ReadHeader()
7557 if err != nil {
7558 return err
7559 }
7560
7561 if extra > 8192 {
7562 return fmt.Errorf("t.Inputs: array too large (%d)", extra)
7563 }
7564
7565 if maj != cbg.MajArray {
7566 return fmt.Errorf("expected cbor array")
7567 }
7568
7569 if extra > 0 {
7570 t.Inputs = make([]*Pipeline_Pair, extra)
7571 }
7572
7573 for i := 0; i < int(extra); i++ {
7574 {
7575 var maj byte
7576 var extra uint64
7577 var err error
7578 _ = maj
7579 _ = extra
7580 _ = err
7581
7582 {
7583
7584 b, err := cr.ReadByte()
7585 if err != nil {
7586 return err
7587 }
7588 if b != cbg.CborNull[0] {
7589 if err := cr.UnreadByte(); err != nil {
7590 return err
7591 }
7592 t.Inputs[i] = new(Pipeline_Pair)
7593 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
7594 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
7595 }
7596 }
7597
7598 }
7599
7600 }
7601 }
7602
7603 default:
7604 // Field doesn't exist on this type, so ignore it
7605 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7606 return err
7607 }
7608 }
7609 }
7610
7611 return nil
7612}
7613func (t *Pipeline_Pair) MarshalCBOR(w io.Writer) error {
7614 if t == nil {
7615 _, err := w.Write(cbg.CborNull)
7616 return err
7617 }
7618
7619 cw := cbg.NewCborWriter(w)
7620
7621 if _, err := cw.Write([]byte{162}); err != nil {
7622 return err
7623 }
7624
7625 // t.Key (string) (string)
7626 if len("key") > 1000000 {
7627 return xerrors.Errorf("Value in field \"key\" was too long")
7628 }
7629
7630 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
7631 return err
7632 }
7633 if _, err := cw.WriteString(string("key")); err != nil {
7634 return err
7635 }
7636
7637 if len(t.Key) > 1000000 {
7638 return xerrors.Errorf("Value in field t.Key was too long")
7639 }
7640
7641 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
7642 return err
7643 }
7644 if _, err := cw.WriteString(string(t.Key)); err != nil {
7645 return err
7646 }
7647
7648 // t.Value (string) (string)
7649 if len("value") > 1000000 {
7650 return xerrors.Errorf("Value in field \"value\" was too long")
7651 }
7652
7653 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
7654 return err
7655 }
7656 if _, err := cw.WriteString(string("value")); err != nil {
7657 return err
7658 }
7659
7660 if len(t.Value) > 1000000 {
7661 return xerrors.Errorf("Value in field t.Value was too long")
7662 }
7663
7664 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
7665 return err
7666 }
7667 if _, err := cw.WriteString(string(t.Value)); err != nil {
7668 return err
7669 }
7670 return nil
7671}
7672
7673func (t *Pipeline_Pair) UnmarshalCBOR(r io.Reader) (err error) {
7674 *t = Pipeline_Pair{}
7675
7676 cr := cbg.NewCborReader(r)
7677
7678 maj, extra, err := cr.ReadHeader()
7679 if err != nil {
7680 return err
7681 }
7682 defer func() {
7683 if err == io.EOF {
7684 err = io.ErrUnexpectedEOF
7685 }
7686 }()
7687
7688 if maj != cbg.MajMap {
7689 return fmt.Errorf("cbor input should be of type map")
7690 }
7691
7692 if extra > cbg.MaxLength {
7693 return fmt.Errorf("Pipeline_Pair: map struct too large (%d)", extra)
7694 }
7695
7696 n := extra
7697
7698 nameBuf := make([]byte, 5)
7699 for i := uint64(0); i < n; i++ {
7700 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7701 if err != nil {
7702 return err
7703 }
7704
7705 if !ok {
7706 // Field doesn't exist on this type, so ignore it
7707 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7708 return err
7709 }
7710 continue
7711 }
7712
7713 switch string(nameBuf[:nameLen]) {
7714 // t.Key (string) (string)
7715 case "key":
7716
7717 {
7718 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7719 if err != nil {
7720 return err
7721 }
7722
7723 t.Key = string(sval)
7724 }
7725 // t.Value (string) (string)
7726 case "value":
7727
7728 {
7729 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7730 if err != nil {
7731 return err
7732 }
7733
7734 t.Value = string(sval)
7735 }
7736
7737 default:
7738 // Field doesn't exist on this type, so ignore it
7739 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7740 return err
7741 }
7742 }
7743 }
7744
7745 return nil
7746}
7747func (t *Pipeline_PullRequestTriggerData) MarshalCBOR(w io.Writer) error {
7748 if t == nil {
7749 _, err := w.Write(cbg.CborNull)
7750 return err
7751 }
7752
7753 cw := cbg.NewCborWriter(w)
7754
7755 if _, err := cw.Write([]byte{164}); err != nil {
7756 return err
7757 }
7758
7759 // t.Action (string) (string)
7760 if len("action") > 1000000 {
7761 return xerrors.Errorf("Value in field \"action\" was too long")
7762 }
7763
7764 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("action"))); err != nil {
7765 return err
7766 }
7767 if _, err := cw.WriteString(string("action")); err != nil {
7768 return err
7769 }
7770
7771 if len(t.Action) > 1000000 {
7772 return xerrors.Errorf("Value in field t.Action was too long")
7773 }
7774
7775 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Action))); err != nil {
7776 return err
7777 }
7778 if _, err := cw.WriteString(string(t.Action)); err != nil {
7779 return err
7780 }
7781
7782 // t.SourceSha (string) (string)
7783 if len("sourceSha") > 1000000 {
7784 return xerrors.Errorf("Value in field \"sourceSha\" was too long")
7785 }
7786
7787 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceSha"))); err != nil {
7788 return err
7789 }
7790 if _, err := cw.WriteString(string("sourceSha")); err != nil {
7791 return err
7792 }
7793
7794 if len(t.SourceSha) > 1000000 {
7795 return xerrors.Errorf("Value in field t.SourceSha was too long")
7796 }
7797
7798 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceSha))); err != nil {
7799 return err
7800 }
7801 if _, err := cw.WriteString(string(t.SourceSha)); err != nil {
7802 return err
7803 }
7804
7805 // t.SourceBranch (string) (string)
7806 if len("sourceBranch") > 1000000 {
7807 return xerrors.Errorf("Value in field \"sourceBranch\" was too long")
7808 }
7809
7810 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceBranch"))); err != nil {
7811 return err
7812 }
7813 if _, err := cw.WriteString(string("sourceBranch")); err != nil {
7814 return err
7815 }
7816
7817 if len(t.SourceBranch) > 1000000 {
7818 return xerrors.Errorf("Value in field t.SourceBranch was too long")
7819 }
7820
7821 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceBranch))); err != nil {
7822 return err
7823 }
7824 if _, err := cw.WriteString(string(t.SourceBranch)); err != nil {
7825 return err
7826 }
7827
7828 // t.TargetBranch (string) (string)
7829 if len("targetBranch") > 1000000 {
7830 return xerrors.Errorf("Value in field \"targetBranch\" was too long")
7831 }
7832
7833 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil {
7834 return err
7835 }
7836 if _, err := cw.WriteString(string("targetBranch")); err != nil {
7837 return err
7838 }
7839
7840 if len(t.TargetBranch) > 1000000 {
7841 return xerrors.Errorf("Value in field t.TargetBranch was too long")
7842 }
7843
7844 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil {
7845 return err
7846 }
7847 if _, err := cw.WriteString(string(t.TargetBranch)); err != nil {
7848 return err
7849 }
7850 return nil
7851}
7852
7853func (t *Pipeline_PullRequestTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
7854 *t = Pipeline_PullRequestTriggerData{}
7855
7856 cr := cbg.NewCborReader(r)
7857
7858 maj, extra, err := cr.ReadHeader()
7859 if err != nil {
7860 return err
7861 }
7862 defer func() {
7863 if err == io.EOF {
7864 err = io.ErrUnexpectedEOF
7865 }
7866 }()
7867
7868 if maj != cbg.MajMap {
7869 return fmt.Errorf("cbor input should be of type map")
7870 }
7871
7872 if extra > cbg.MaxLength {
7873 return fmt.Errorf("Pipeline_PullRequestTriggerData: map struct too large (%d)", extra)
7874 }
7875
7876 n := extra
7877
7878 nameBuf := make([]byte, 12)
7879 for i := uint64(0); i < n; i++ {
7880 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7881 if err != nil {
7882 return err
7883 }
7884
7885 if !ok {
7886 // Field doesn't exist on this type, so ignore it
7887 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7888 return err
7889 }
7890 continue
7891 }
7892
7893 switch string(nameBuf[:nameLen]) {
7894 // t.Action (string) (string)
7895 case "action":
7896
7897 {
7898 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7899 if err != nil {
7900 return err
7901 }
7902
7903 t.Action = string(sval)
7904 }
7905 // t.SourceSha (string) (string)
7906 case "sourceSha":
7907
7908 {
7909 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7910 if err != nil {
7911 return err
7912 }
7913
7914 t.SourceSha = string(sval)
7915 }
7916 // t.SourceBranch (string) (string)
7917 case "sourceBranch":
7918
7919 {
7920 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7921 if err != nil {
7922 return err
7923 }
7924
7925 t.SourceBranch = string(sval)
7926 }
7927 // t.TargetBranch (string) (string)
7928 case "targetBranch":
7929
7930 {
7931 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7932 if err != nil {
7933 return err
7934 }
7935
7936 t.TargetBranch = string(sval)
7937 }
7938
7939 default:
7940 // Field doesn't exist on this type, so ignore it
7941 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7942 return err
7943 }
7944 }
7945 }
7946
7947 return nil
7948}
7949func (t *Pipeline_PushTriggerData) MarshalCBOR(w io.Writer) error {
7950 if t == nil {
7951 _, err := w.Write(cbg.CborNull)
7952 return err
7953 }
7954
7955 cw := cbg.NewCborWriter(w)
7956
7957 if _, err := cw.Write([]byte{163}); err != nil {
7958 return err
7959 }
7960
7961 // t.Ref (string) (string)
7962 if len("ref") > 1000000 {
7963 return xerrors.Errorf("Value in field \"ref\" was too long")
7964 }
7965
7966 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
7967 return err
7968 }
7969 if _, err := cw.WriteString(string("ref")); err != nil {
7970 return err
7971 }
7972
7973 if len(t.Ref) > 1000000 {
7974 return xerrors.Errorf("Value in field t.Ref was too long")
7975 }
7976
7977 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
7978 return err
7979 }
7980 if _, err := cw.WriteString(string(t.Ref)); err != nil {
7981 return err
7982 }
7983
7984 // t.NewSha (string) (string)
7985 if len("newSha") > 1000000 {
7986 return xerrors.Errorf("Value in field \"newSha\" was too long")
7987 }
7988
7989 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
7990 return err
7991 }
7992 if _, err := cw.WriteString(string("newSha")); err != nil {
7993 return err
7994 }
7995
7996 if len(t.NewSha) > 1000000 {
7997 return xerrors.Errorf("Value in field t.NewSha was too long")
7998 }
7999
8000 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
8001 return err
8002 }
8003 if _, err := cw.WriteString(string(t.NewSha)); err != nil {
8004 return err
8005 }
8006
8007 // t.OldSha (string) (string)
8008 if len("oldSha") > 1000000 {
8009 return xerrors.Errorf("Value in field \"oldSha\" was too long")
8010 }
8011
8012 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
8013 return err
8014 }
8015 if _, err := cw.WriteString(string("oldSha")); err != nil {
8016 return err
8017 }
8018
8019 if len(t.OldSha) > 1000000 {
8020 return xerrors.Errorf("Value in field t.OldSha was too long")
8021 }
8022
8023 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
8024 return err
8025 }
8026 if _, err := cw.WriteString(string(t.OldSha)); err != nil {
8027 return err
8028 }
8029 return nil
8030}
8031
8032func (t *Pipeline_PushTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
8033 *t = Pipeline_PushTriggerData{}
8034
8035 cr := cbg.NewCborReader(r)
8036
8037 maj, extra, err := cr.ReadHeader()
8038 if err != nil {
8039 return err
8040 }
8041 defer func() {
8042 if err == io.EOF {
8043 err = io.ErrUnexpectedEOF
8044 }
8045 }()
8046
8047 if maj != cbg.MajMap {
8048 return fmt.Errorf("cbor input should be of type map")
8049 }
8050
8051 if extra > cbg.MaxLength {
8052 return fmt.Errorf("Pipeline_PushTriggerData: map struct too large (%d)", extra)
8053 }
8054
8055 n := extra
8056
8057 nameBuf := make([]byte, 6)
8058 for i := uint64(0); i < n; i++ {
8059 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8060 if err != nil {
8061 return err
8062 }
8063
8064 if !ok {
8065 // Field doesn't exist on this type, so ignore it
8066 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8067 return err
8068 }
8069 continue
8070 }
8071
8072 switch string(nameBuf[:nameLen]) {
8073 // t.Ref (string) (string)
8074 case "ref":
8075
8076 {
8077 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8078 if err != nil {
8079 return err
8080 }
8081
8082 t.Ref = string(sval)
8083 }
8084 // t.NewSha (string) (string)
8085 case "newSha":
8086
8087 {
8088 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8089 if err != nil {
8090 return err
8091 }
8092
8093 t.NewSha = string(sval)
8094 }
8095 // t.OldSha (string) (string)
8096 case "oldSha":
8097
8098 {
8099 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8100 if err != nil {
8101 return err
8102 }
8103
8104 t.OldSha = string(sval)
8105 }
8106
8107 default:
8108 // Field doesn't exist on this type, so ignore it
8109 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8110 return err
8111 }
8112 }
8113 }
8114
8115 return nil
8116}
8117func (t *PipelineStatus) MarshalCBOR(w io.Writer) error {
8118 if t == nil {
8119 _, err := w.Write(cbg.CborNull)
8120 return err
8121 }
8122
8123 cw := cbg.NewCborWriter(w)
8124 fieldCount := 7
8125
8126 if t.Error == nil {
8127 fieldCount--
8128 }
8129
8130 if t.ExitCode == nil {
8131 fieldCount--
8132 }
8133
8134 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
8135 return err
8136 }
8137
8138 // t.LexiconTypeID (string) (string)
8139 if len("$type") > 1000000 {
8140 return xerrors.Errorf("Value in field \"$type\" was too long")
8141 }
8142
8143 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8144 return err
8145 }
8146 if _, err := cw.WriteString(string("$type")); err != nil {
8147 return err
8148 }
8149
8150 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline.status"))); err != nil {
8151 return err
8152 }
8153 if _, err := cw.WriteString(string("sh.tangled.pipeline.status")); err != nil {
8154 return err
8155 }
8156
8157 // t.Error (string) (string)
8158 if t.Error != nil {
8159
8160 if len("error") > 1000000 {
8161 return xerrors.Errorf("Value in field \"error\" was too long")
8162 }
8163
8164 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("error"))); err != nil {
8165 return err
8166 }
8167 if _, err := cw.WriteString(string("error")); err != nil {
8168 return err
8169 }
8170
8171 if t.Error == nil {
8172 if _, err := cw.Write(cbg.CborNull); err != nil {
8173 return err
8174 }
8175 } else {
8176 if len(*t.Error) > 1000000 {
8177 return xerrors.Errorf("Value in field t.Error was too long")
8178 }
8179
8180 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Error))); err != nil {
8181 return err
8182 }
8183 if _, err := cw.WriteString(string(*t.Error)); err != nil {
8184 return err
8185 }
8186 }
8187 }
8188
8189 // t.Status (string) (string)
8190 if len("status") > 1000000 {
8191 return xerrors.Errorf("Value in field \"status\" was too long")
8192 }
8193
8194 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
8195 return err
8196 }
8197 if _, err := cw.WriteString(string("status")); err != nil {
8198 return err
8199 }
8200
8201 if len(t.Status) > 1000000 {
8202 return xerrors.Errorf("Value in field t.Status was too long")
8203 }
8204
8205 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
8206 return err
8207 }
8208 if _, err := cw.WriteString(string(t.Status)); err != nil {
8209 return err
8210 }
8211
8212 // t.ExitCode (int64) (int64)
8213 if t.ExitCode != nil {
8214
8215 if len("exitCode") > 1000000 {
8216 return xerrors.Errorf("Value in field \"exitCode\" was too long")
8217 }
8218
8219 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("exitCode"))); err != nil {
8220 return err
8221 }
8222 if _, err := cw.WriteString(string("exitCode")); err != nil {
8223 return err
8224 }
8225
8226 if t.ExitCode == nil {
8227 if _, err := cw.Write(cbg.CborNull); err != nil {
8228 return err
8229 }
8230 } else {
8231 if *t.ExitCode >= 0 {
8232 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.ExitCode)); err != nil {
8233 return err
8234 }
8235 } else {
8236 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.ExitCode-1)); err != nil {
8237 return err
8238 }
8239 }
8240 }
8241
8242 }
8243
8244 // t.Pipeline (string) (string)
8245 if len("pipeline") > 1000000 {
8246 return xerrors.Errorf("Value in field \"pipeline\" was too long")
8247 }
8248
8249 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pipeline"))); err != nil {
8250 return err
8251 }
8252 if _, err := cw.WriteString(string("pipeline")); err != nil {
8253 return err
8254 }
8255
8256 if len(t.Pipeline) > 1000000 {
8257 return xerrors.Errorf("Value in field t.Pipeline was too long")
8258 }
8259
8260 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pipeline))); err != nil {
8261 return err
8262 }
8263 if _, err := cw.WriteString(string(t.Pipeline)); err != nil {
8264 return err
8265 }
8266
8267 // t.Workflow (string) (string)
8268 if len("workflow") > 1000000 {
8269 return xerrors.Errorf("Value in field \"workflow\" was too long")
8270 }
8271
8272 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil {
8273 return err
8274 }
8275 if _, err := cw.WriteString(string("workflow")); err != nil {
8276 return err
8277 }
8278
8279 if len(t.Workflow) > 1000000 {
8280 return xerrors.Errorf("Value in field t.Workflow was too long")
8281 }
8282
8283 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil {
8284 return err
8285 }
8286 if _, err := cw.WriteString(string(t.Workflow)); err != nil {
8287 return err
8288 }
8289
8290 // t.CreatedAt (string) (string)
8291 if len("createdAt") > 1000000 {
8292 return xerrors.Errorf("Value in field \"createdAt\" was too long")
8293 }
8294
8295 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
8296 return err
8297 }
8298 if _, err := cw.WriteString(string("createdAt")); err != nil {
8299 return err
8300 }
8301
8302 if len(t.CreatedAt) > 1000000 {
8303 return xerrors.Errorf("Value in field t.CreatedAt was too long")
8304 }
8305
8306 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
8307 return err
8308 }
8309 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
8310 return err
8311 }
8312 return nil
8313}
8314
8315func (t *PipelineStatus) UnmarshalCBOR(r io.Reader) (err error) {
8316 *t = PipelineStatus{}
8317
8318 cr := cbg.NewCborReader(r)
8319
8320 maj, extra, err := cr.ReadHeader()
8321 if err != nil {
8322 return err
8323 }
8324 defer func() {
8325 if err == io.EOF {
8326 err = io.ErrUnexpectedEOF
8327 }
8328 }()
8329
8330 if maj != cbg.MajMap {
8331 return fmt.Errorf("cbor input should be of type map")
8332 }
8333
8334 if extra > cbg.MaxLength {
8335 return fmt.Errorf("PipelineStatus: map struct too large (%d)", extra)
8336 }
8337
8338 n := extra
8339
8340 nameBuf := make([]byte, 9)
8341 for i := uint64(0); i < n; i++ {
8342 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8343 if err != nil {
8344 return err
8345 }
8346
8347 if !ok {
8348 // Field doesn't exist on this type, so ignore it
8349 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8350 return err
8351 }
8352 continue
8353 }
8354
8355 switch string(nameBuf[:nameLen]) {
8356 // t.LexiconTypeID (string) (string)
8357 case "$type":
8358
8359 {
8360 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8361 if err != nil {
8362 return err
8363 }
8364
8365 t.LexiconTypeID = string(sval)
8366 }
8367 // t.Error (string) (string)
8368 case "error":
8369
8370 {
8371 b, err := cr.ReadByte()
8372 if err != nil {
8373 return err
8374 }
8375 if b != cbg.CborNull[0] {
8376 if err := cr.UnreadByte(); err != nil {
8377 return err
8378 }
8379
8380 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8381 if err != nil {
8382 return err
8383 }
8384
8385 t.Error = (*string)(&sval)
8386 }
8387 }
8388 // t.Status (string) (string)
8389 case "status":
8390
8391 {
8392 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8393 if err != nil {
8394 return err
8395 }
8396
8397 t.Status = string(sval)
8398 }
8399 // t.ExitCode (int64) (int64)
8400 case "exitCode":
8401 {
8402
8403 b, err := cr.ReadByte()
8404 if err != nil {
8405 return err
8406 }
8407 if b != cbg.CborNull[0] {
8408 if err := cr.UnreadByte(); err != nil {
8409 return err
8410 }
8411 maj, extra, err := cr.ReadHeader()
8412 if err != nil {
8413 return err
8414 }
8415 var extraI int64
8416 switch maj {
8417 case cbg.MajUnsignedInt:
8418 extraI = int64(extra)
8419 if extraI < 0 {
8420 return fmt.Errorf("int64 positive overflow")
8421 }
8422 case cbg.MajNegativeInt:
8423 extraI = int64(extra)
8424 if extraI < 0 {
8425 return fmt.Errorf("int64 negative overflow")
8426 }
8427 extraI = -1 - extraI
8428 default:
8429 return fmt.Errorf("wrong type for int64 field: %d", maj)
8430 }
8431
8432 t.ExitCode = (*int64)(&extraI)
8433 }
8434 }
8435 // t.Pipeline (string) (string)
8436 case "pipeline":
8437
8438 {
8439 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8440 if err != nil {
8441 return err
8442 }
8443
8444 t.Pipeline = string(sval)
8445 }
8446 // t.Workflow (string) (string)
8447 case "workflow":
8448
8449 {
8450 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8451 if err != nil {
8452 return err
8453 }
8454
8455 t.Workflow = string(sval)
8456 }
8457 // t.CreatedAt (string) (string)
8458 case "createdAt":
8459
8460 {
8461 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8462 if err != nil {
8463 return err
8464 }
8465
8466 t.CreatedAt = string(sval)
8467 }
8468
8469 default:
8470 // Field doesn't exist on this type, so ignore it
8471 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8472 return err
8473 }
8474 }
8475 }
8476
8477 return nil
8478}
8479func (t *Pipeline_TriggerMetadata) MarshalCBOR(w io.Writer) error {
8480 if t == nil {
8481 _, err := w.Write(cbg.CborNull)
8482 return err
8483 }
8484
8485 cw := cbg.NewCborWriter(w)
8486 fieldCount := 5
8487
8488 if t.Manual == nil {
8489 fieldCount--
8490 }
8491
8492 if t.PullRequest == nil {
8493 fieldCount--
8494 }
8495
8496 if t.Push == nil {
8497 fieldCount--
8498 }
8499
8500 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
8501 return err
8502 }
8503
8504 // t.Kind (string) (string)
8505 if len("kind") > 1000000 {
8506 return xerrors.Errorf("Value in field \"kind\" was too long")
8507 }
8508
8509 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("kind"))); err != nil {
8510 return err
8511 }
8512 if _, err := cw.WriteString(string("kind")); err != nil {
8513 return err
8514 }
8515
8516 if len(t.Kind) > 1000000 {
8517 return xerrors.Errorf("Value in field t.Kind was too long")
8518 }
8519
8520 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Kind))); err != nil {
8521 return err
8522 }
8523 if _, err := cw.WriteString(string(t.Kind)); err != nil {
8524 return err
8525 }
8526
8527 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
8528 if t.Push != nil {
8529
8530 if len("push") > 1000000 {
8531 return xerrors.Errorf("Value in field \"push\" was too long")
8532 }
8533
8534 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("push"))); err != nil {
8535 return err
8536 }
8537 if _, err := cw.WriteString(string("push")); err != nil {
8538 return err
8539 }
8540
8541 if err := t.Push.MarshalCBOR(cw); err != nil {
8542 return err
8543 }
8544 }
8545
8546 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
8547 if len("repo") > 1000000 {
8548 return xerrors.Errorf("Value in field \"repo\" was too long")
8549 }
8550
8551 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
8552 return err
8553 }
8554 if _, err := cw.WriteString(string("repo")); err != nil {
8555 return err
8556 }
8557
8558 if err := t.Repo.MarshalCBOR(cw); err != nil {
8559 return err
8560 }
8561
8562 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
8563 if t.Manual != nil {
8564
8565 if len("manual") > 1000000 {
8566 return xerrors.Errorf("Value in field \"manual\" was too long")
8567 }
8568
8569 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("manual"))); err != nil {
8570 return err
8571 }
8572 if _, err := cw.WriteString(string("manual")); err != nil {
8573 return err
8574 }
8575
8576 if err := t.Manual.MarshalCBOR(cw); err != nil {
8577 return err
8578 }
8579 }
8580
8581 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
8582 if t.PullRequest != nil {
8583
8584 if len("pullRequest") > 1000000 {
8585 return xerrors.Errorf("Value in field \"pullRequest\" was too long")
8586 }
8587
8588 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullRequest"))); err != nil {
8589 return err
8590 }
8591 if _, err := cw.WriteString(string("pullRequest")); err != nil {
8592 return err
8593 }
8594
8595 if err := t.PullRequest.MarshalCBOR(cw); err != nil {
8596 return err
8597 }
8598 }
8599 return nil
8600}
8601
8602func (t *Pipeline_TriggerMetadata) UnmarshalCBOR(r io.Reader) (err error) {
8603 *t = Pipeline_TriggerMetadata{}
8604
8605 cr := cbg.NewCborReader(r)
8606
8607 maj, extra, err := cr.ReadHeader()
8608 if err != nil {
8609 return err
8610 }
8611 defer func() {
8612 if err == io.EOF {
8613 err = io.ErrUnexpectedEOF
8614 }
8615 }()
8616
8617 if maj != cbg.MajMap {
8618 return fmt.Errorf("cbor input should be of type map")
8619 }
8620
8621 if extra > cbg.MaxLength {
8622 return fmt.Errorf("Pipeline_TriggerMetadata: map struct too large (%d)", extra)
8623 }
8624
8625 n := extra
8626
8627 nameBuf := make([]byte, 11)
8628 for i := uint64(0); i < n; i++ {
8629 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8630 if err != nil {
8631 return err
8632 }
8633
8634 if !ok {
8635 // Field doesn't exist on this type, so ignore it
8636 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8637 return err
8638 }
8639 continue
8640 }
8641
8642 switch string(nameBuf[:nameLen]) {
8643 // t.Kind (string) (string)
8644 case "kind":
8645
8646 {
8647 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8648 if err != nil {
8649 return err
8650 }
8651
8652 t.Kind = string(sval)
8653 }
8654 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
8655 case "push":
8656
8657 {
8658
8659 b, err := cr.ReadByte()
8660 if err != nil {
8661 return err
8662 }
8663 if b != cbg.CborNull[0] {
8664 if err := cr.UnreadByte(); err != nil {
8665 return err
8666 }
8667 t.Push = new(Pipeline_PushTriggerData)
8668 if err := t.Push.UnmarshalCBOR(cr); err != nil {
8669 return xerrors.Errorf("unmarshaling t.Push pointer: %w", err)
8670 }
8671 }
8672
8673 }
8674 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
8675 case "repo":
8676
8677 {
8678
8679 b, err := cr.ReadByte()
8680 if err != nil {
8681 return err
8682 }
8683 if b != cbg.CborNull[0] {
8684 if err := cr.UnreadByte(); err != nil {
8685 return err
8686 }
8687 t.Repo = new(Pipeline_TriggerRepo)
8688 if err := t.Repo.UnmarshalCBOR(cr); err != nil {
8689 return xerrors.Errorf("unmarshaling t.Repo pointer: %w", err)
8690 }
8691 }
8692
8693 }
8694 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
8695 case "manual":
8696
8697 {
8698
8699 b, err := cr.ReadByte()
8700 if err != nil {
8701 return err
8702 }
8703 if b != cbg.CborNull[0] {
8704 if err := cr.UnreadByte(); err != nil {
8705 return err
8706 }
8707 t.Manual = new(Pipeline_ManualTriggerData)
8708 if err := t.Manual.UnmarshalCBOR(cr); err != nil {
8709 return xerrors.Errorf("unmarshaling t.Manual pointer: %w", err)
8710 }
8711 }
8712
8713 }
8714 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
8715 case "pullRequest":
8716
8717 {
8718
8719 b, err := cr.ReadByte()
8720 if err != nil {
8721 return err
8722 }
8723 if b != cbg.CborNull[0] {
8724 if err := cr.UnreadByte(); err != nil {
8725 return err
8726 }
8727 t.PullRequest = new(Pipeline_PullRequestTriggerData)
8728 if err := t.PullRequest.UnmarshalCBOR(cr); err != nil {
8729 return xerrors.Errorf("unmarshaling t.PullRequest pointer: %w", err)
8730 }
8731 }
8732
8733 }
8734
8735 default:
8736 // Field doesn't exist on this type, so ignore it
8737 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8738 return err
8739 }
8740 }
8741 }
8742
8743 return nil
8744}
8745func (t *Pipeline_TriggerRepo) MarshalCBOR(w io.Writer) error {
8746 if t == nil {
8747 _, err := w.Write(cbg.CborNull)
8748 return err
8749 }
8750
8751 cw := cbg.NewCborWriter(w)
8752 fieldCount := 5
8753
8754 if t.Repo == nil {
8755 fieldCount--
8756 }
8757
8758 if t.RepoDid == nil {
8759 fieldCount--
8760 }
8761
8762 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
8763 return err
8764 }
8765
8766 // t.Did (string) (string)
8767 if len("did") > 1000000 {
8768 return xerrors.Errorf("Value in field \"did\" was too long")
8769 }
8770
8771 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil {
8772 return err
8773 }
8774 if _, err := cw.WriteString(string("did")); err != nil {
8775 return err
8776 }
8777
8778 if len(t.Did) > 1000000 {
8779 return xerrors.Errorf("Value in field t.Did was too long")
8780 }
8781
8782 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil {
8783 return err
8784 }
8785 if _, err := cw.WriteString(string(t.Did)); err != nil {
8786 return err
8787 }
8788
8789 // t.Knot (string) (string)
8790 if len("knot") > 1000000 {
8791 return xerrors.Errorf("Value in field \"knot\" was too long")
8792 }
8793
8794 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
8795 return err
8796 }
8797 if _, err := cw.WriteString(string("knot")); err != nil {
8798 return err
8799 }
8800
8801 if len(t.Knot) > 1000000 {
8802 return xerrors.Errorf("Value in field t.Knot was too long")
8803 }
8804
8805 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
8806 return err
8807 }
8808 if _, err := cw.WriteString(string(t.Knot)); err != nil {
8809 return err
8810 }
8811
8812 // t.Repo (string) (string)
8813 if t.Repo != nil {
8814
8815 if len("repo") > 1000000 {
8816 return xerrors.Errorf("Value in field \"repo\" was too long")
8817 }
8818
8819 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
8820 return err
8821 }
8822 if _, err := cw.WriteString(string("repo")); err != nil {
8823 return err
8824 }
8825
8826 if t.Repo == nil {
8827 if _, err := cw.Write(cbg.CborNull); err != nil {
8828 return err
8829 }
8830 } else {
8831 if len(*t.Repo) > 1000000 {
8832 return xerrors.Errorf("Value in field t.Repo was too long")
8833 }
8834
8835 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
8836 return err
8837 }
8838 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
8839 return err
8840 }
8841 }
8842 }
8843
8844 // t.RepoDid (string) (string)
8845 if t.RepoDid != nil {
8846
8847 if len("repoDid") > 1000000 {
8848 return xerrors.Errorf("Value in field \"repoDid\" was too long")
8849 }
8850
8851 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
8852 return err
8853 }
8854 if _, err := cw.WriteString(string("repoDid")); err != nil {
8855 return err
8856 }
8857
8858 if t.RepoDid == nil {
8859 if _, err := cw.Write(cbg.CborNull); err != nil {
8860 return err
8861 }
8862 } else {
8863 if len(*t.RepoDid) > 1000000 {
8864 return xerrors.Errorf("Value in field t.RepoDid was too long")
8865 }
8866
8867 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil {
8868 return err
8869 }
8870 if _, err := cw.WriteString(string(*t.RepoDid)); err != nil {
8871 return err
8872 }
8873 }
8874 }
8875
8876 // t.DefaultBranch (string) (string)
8877 if len("defaultBranch") > 1000000 {
8878 return xerrors.Errorf("Value in field \"defaultBranch\" was too long")
8879 }
8880
8881 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("defaultBranch"))); err != nil {
8882 return err
8883 }
8884 if _, err := cw.WriteString(string("defaultBranch")); err != nil {
8885 return err
8886 }
8887
8888 if len(t.DefaultBranch) > 1000000 {
8889 return xerrors.Errorf("Value in field t.DefaultBranch was too long")
8890 }
8891
8892 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.DefaultBranch))); err != nil {
8893 return err
8894 }
8895 if _, err := cw.WriteString(string(t.DefaultBranch)); err != nil {
8896 return err
8897 }
8898 return nil
8899}
8900
8901func (t *Pipeline_TriggerRepo) UnmarshalCBOR(r io.Reader) (err error) {
8902 *t = Pipeline_TriggerRepo{}
8903
8904 cr := cbg.NewCborReader(r)
8905
8906 maj, extra, err := cr.ReadHeader()
8907 if err != nil {
8908 return err
8909 }
8910 defer func() {
8911 if err == io.EOF {
8912 err = io.ErrUnexpectedEOF
8913 }
8914 }()
8915
8916 if maj != cbg.MajMap {
8917 return fmt.Errorf("cbor input should be of type map")
8918 }
8919
8920 if extra > cbg.MaxLength {
8921 return fmt.Errorf("Pipeline_TriggerRepo: map struct too large (%d)", extra)
8922 }
8923
8924 n := extra
8925
8926 nameBuf := make([]byte, 13)
8927 for i := uint64(0); i < n; i++ {
8928 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8929 if err != nil {
8930 return err
8931 }
8932
8933 if !ok {
8934 // Field doesn't exist on this type, so ignore it
8935 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8936 return err
8937 }
8938 continue
8939 }
8940
8941 switch string(nameBuf[:nameLen]) {
8942 // t.Did (string) (string)
8943 case "did":
8944
8945 {
8946 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8947 if err != nil {
8948 return err
8949 }
8950
8951 t.Did = string(sval)
8952 }
8953 // t.Knot (string) (string)
8954 case "knot":
8955
8956 {
8957 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8958 if err != nil {
8959 return err
8960 }
8961
8962 t.Knot = string(sval)
8963 }
8964 // t.Repo (string) (string)
8965 case "repo":
8966
8967 {
8968 b, err := cr.ReadByte()
8969 if err != nil {
8970 return err
8971 }
8972 if b != cbg.CborNull[0] {
8973 if err := cr.UnreadByte(); err != nil {
8974 return err
8975 }
8976
8977 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8978 if err != nil {
8979 return err
8980 }
8981
8982 t.Repo = (*string)(&sval)
8983 }
8984 }
8985 // t.RepoDid (string) (string)
8986 case "repoDid":
8987
8988 {
8989 b, err := cr.ReadByte()
8990 if err != nil {
8991 return err
8992 }
8993 if b != cbg.CborNull[0] {
8994 if err := cr.UnreadByte(); err != nil {
8995 return err
8996 }
8997
8998 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8999 if err != nil {
9000 return err
9001 }
9002
9003 t.RepoDid = (*string)(&sval)
9004 }
9005 }
9006 // t.DefaultBranch (string) (string)
9007 case "defaultBranch":
9008
9009 {
9010 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9011 if err != nil {
9012 return err
9013 }
9014
9015 t.DefaultBranch = string(sval)
9016 }
9017
9018 default:
9019 // Field doesn't exist on this type, so ignore it
9020 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9021 return err
9022 }
9023 }
9024 }
9025
9026 return nil
9027}
9028func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error {
9029 if t == nil {
9030 _, err := w.Write(cbg.CborNull)
9031 return err
9032 }
9033
9034 cw := cbg.NewCborWriter(w)
9035
9036 if _, err := cw.Write([]byte{164}); err != nil {
9037 return err
9038 }
9039
9040 // t.Raw (string) (string)
9041 if len("raw") > 1000000 {
9042 return xerrors.Errorf("Value in field \"raw\" was too long")
9043 }
9044
9045 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("raw"))); err != nil {
9046 return err
9047 }
9048 if _, err := cw.WriteString(string("raw")); err != nil {
9049 return err
9050 }
9051
9052 if len(t.Raw) > 1000000 {
9053 return xerrors.Errorf("Value in field t.Raw was too long")
9054 }
9055
9056 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Raw))); err != nil {
9057 return err
9058 }
9059 if _, err := cw.WriteString(string(t.Raw)); err != nil {
9060 return err
9061 }
9062
9063 // t.Name (string) (string)
9064 if len("name") > 1000000 {
9065 return xerrors.Errorf("Value in field \"name\" was too long")
9066 }
9067
9068 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
9069 return err
9070 }
9071 if _, err := cw.WriteString(string("name")); err != nil {
9072 return err
9073 }
9074
9075 if len(t.Name) > 1000000 {
9076 return xerrors.Errorf("Value in field t.Name was too long")
9077 }
9078
9079 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
9080 return err
9081 }
9082 if _, err := cw.WriteString(string(t.Name)); err != nil {
9083 return err
9084 }
9085
9086 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
9087 if len("clone") > 1000000 {
9088 return xerrors.Errorf("Value in field \"clone\" was too long")
9089 }
9090
9091 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil {
9092 return err
9093 }
9094 if _, err := cw.WriteString(string("clone")); err != nil {
9095 return err
9096 }
9097
9098 if err := t.Clone.MarshalCBOR(cw); err != nil {
9099 return err
9100 }
9101
9102 // t.Engine (string) (string)
9103 if len("engine") > 1000000 {
9104 return xerrors.Errorf("Value in field \"engine\" was too long")
9105 }
9106
9107 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("engine"))); err != nil {
9108 return err
9109 }
9110 if _, err := cw.WriteString(string("engine")); err != nil {
9111 return err
9112 }
9113
9114 if len(t.Engine) > 1000000 {
9115 return xerrors.Errorf("Value in field t.Engine was too long")
9116 }
9117
9118 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Engine))); err != nil {
9119 return err
9120 }
9121 if _, err := cw.WriteString(string(t.Engine)); err != nil {
9122 return err
9123 }
9124 return nil
9125}
9126
9127func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) {
9128 *t = Pipeline_Workflow{}
9129
9130 cr := cbg.NewCborReader(r)
9131
9132 maj, extra, err := cr.ReadHeader()
9133 if err != nil {
9134 return err
9135 }
9136 defer func() {
9137 if err == io.EOF {
9138 err = io.ErrUnexpectedEOF
9139 }
9140 }()
9141
9142 if maj != cbg.MajMap {
9143 return fmt.Errorf("cbor input should be of type map")
9144 }
9145
9146 if extra > cbg.MaxLength {
9147 return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra)
9148 }
9149
9150 n := extra
9151
9152 nameBuf := make([]byte, 6)
9153 for i := uint64(0); i < n; i++ {
9154 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9155 if err != nil {
9156 return err
9157 }
9158
9159 if !ok {
9160 // Field doesn't exist on this type, so ignore it
9161 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9162 return err
9163 }
9164 continue
9165 }
9166
9167 switch string(nameBuf[:nameLen]) {
9168 // t.Raw (string) (string)
9169 case "raw":
9170
9171 {
9172 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9173 if err != nil {
9174 return err
9175 }
9176
9177 t.Raw = string(sval)
9178 }
9179 // t.Name (string) (string)
9180 case "name":
9181
9182 {
9183 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9184 if err != nil {
9185 return err
9186 }
9187
9188 t.Name = string(sval)
9189 }
9190 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
9191 case "clone":
9192
9193 {
9194
9195 b, err := cr.ReadByte()
9196 if err != nil {
9197 return err
9198 }
9199 if b != cbg.CborNull[0] {
9200 if err := cr.UnreadByte(); err != nil {
9201 return err
9202 }
9203 t.Clone = new(Pipeline_CloneOpts)
9204 if err := t.Clone.UnmarshalCBOR(cr); err != nil {
9205 return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err)
9206 }
9207 }
9208
9209 }
9210 // t.Engine (string) (string)
9211 case "engine":
9212
9213 {
9214 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9215 if err != nil {
9216 return err
9217 }
9218
9219 t.Engine = string(sval)
9220 }
9221
9222 default:
9223 // Field doesn't exist on this type, so ignore it
9224 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9225 return err
9226 }
9227 }
9228 }
9229
9230 return nil
9231}
9232func (t *PublicKey) MarshalCBOR(w io.Writer) error {
9233 if t == nil {
9234 _, err := w.Write(cbg.CborNull)
9235 return err
9236 }
9237
9238 cw := cbg.NewCborWriter(w)
9239
9240 if _, err := cw.Write([]byte{164}); err != nil {
9241 return err
9242 }
9243
9244 // t.Key (string) (string)
9245 if len("key") > 1000000 {
9246 return xerrors.Errorf("Value in field \"key\" was too long")
9247 }
9248
9249 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
9250 return err
9251 }
9252 if _, err := cw.WriteString(string("key")); err != nil {
9253 return err
9254 }
9255
9256 if len(t.Key) > 1000000 {
9257 return xerrors.Errorf("Value in field t.Key was too long")
9258 }
9259
9260 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
9261 return err
9262 }
9263 if _, err := cw.WriteString(string(t.Key)); err != nil {
9264 return err
9265 }
9266
9267 // t.Name (string) (string)
9268 if len("name") > 1000000 {
9269 return xerrors.Errorf("Value in field \"name\" was too long")
9270 }
9271
9272 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
9273 return err
9274 }
9275 if _, err := cw.WriteString(string("name")); err != nil {
9276 return err
9277 }
9278
9279 if len(t.Name) > 1000000 {
9280 return xerrors.Errorf("Value in field t.Name was too long")
9281 }
9282
9283 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
9284 return err
9285 }
9286 if _, err := cw.WriteString(string(t.Name)); err != nil {
9287 return err
9288 }
9289
9290 // t.LexiconTypeID (string) (string)
9291 if len("$type") > 1000000 {
9292 return xerrors.Errorf("Value in field \"$type\" was too long")
9293 }
9294
9295 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
9296 return err
9297 }
9298 if _, err := cw.WriteString(string("$type")); err != nil {
9299 return err
9300 }
9301
9302 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil {
9303 return err
9304 }
9305 if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil {
9306 return err
9307 }
9308
9309 // t.CreatedAt (string) (string)
9310 if len("createdAt") > 1000000 {
9311 return xerrors.Errorf("Value in field \"createdAt\" was too long")
9312 }
9313
9314 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
9315 return err
9316 }
9317 if _, err := cw.WriteString(string("createdAt")); err != nil {
9318 return err
9319 }
9320
9321 if len(t.CreatedAt) > 1000000 {
9322 return xerrors.Errorf("Value in field t.CreatedAt was too long")
9323 }
9324
9325 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
9326 return err
9327 }
9328 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
9329 return err
9330 }
9331 return nil
9332}
9333
9334func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) {
9335 *t = PublicKey{}
9336
9337 cr := cbg.NewCborReader(r)
9338
9339 maj, extra, err := cr.ReadHeader()
9340 if err != nil {
9341 return err
9342 }
9343 defer func() {
9344 if err == io.EOF {
9345 err = io.ErrUnexpectedEOF
9346 }
9347 }()
9348
9349 if maj != cbg.MajMap {
9350 return fmt.Errorf("cbor input should be of type map")
9351 }
9352
9353 if extra > cbg.MaxLength {
9354 return fmt.Errorf("PublicKey: map struct too large (%d)", extra)
9355 }
9356
9357 n := extra
9358
9359 nameBuf := make([]byte, 9)
9360 for i := uint64(0); i < n; i++ {
9361 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9362 if err != nil {
9363 return err
9364 }
9365
9366 if !ok {
9367 // Field doesn't exist on this type, so ignore it
9368 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9369 return err
9370 }
9371 continue
9372 }
9373
9374 switch string(nameBuf[:nameLen]) {
9375 // t.Key (string) (string)
9376 case "key":
9377
9378 {
9379 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9380 if err != nil {
9381 return err
9382 }
9383
9384 t.Key = string(sval)
9385 }
9386 // t.Name (string) (string)
9387 case "name":
9388
9389 {
9390 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9391 if err != nil {
9392 return err
9393 }
9394
9395 t.Name = string(sval)
9396 }
9397 // t.LexiconTypeID (string) (string)
9398 case "$type":
9399
9400 {
9401 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9402 if err != nil {
9403 return err
9404 }
9405
9406 t.LexiconTypeID = string(sval)
9407 }
9408 // t.CreatedAt (string) (string)
9409 case "createdAt":
9410
9411 {
9412 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9413 if err != nil {
9414 return err
9415 }
9416
9417 t.CreatedAt = string(sval)
9418 }
9419
9420 default:
9421 // Field doesn't exist on this type, so ignore it
9422 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9423 return err
9424 }
9425 }
9426 }
9427
9428 return nil
9429}
9430func (t *Repo) MarshalCBOR(w io.Writer) error {
9431 if t == nil {
9432 _, err := w.Write(cbg.CborNull)
9433 return err
9434 }
9435
9436 cw := cbg.NewCborWriter(w)
9437 fieldCount := 11
9438
9439 if t.Description == nil {
9440 fieldCount--
9441 }
9442
9443 if t.Labels == nil {
9444 fieldCount--
9445 }
9446
9447 if t.Name == nil {
9448 fieldCount--
9449 }
9450
9451 if t.RepoDid == nil {
9452 fieldCount--
9453 }
9454
9455 if t.Source == nil {
9456 fieldCount--
9457 }
9458
9459 if t.Spindle == nil {
9460 fieldCount--
9461 }
9462
9463 if t.Topics == nil {
9464 fieldCount--
9465 }
9466
9467 if t.Website == nil {
9468 fieldCount--
9469 }
9470
9471 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
9472 return err
9473 }
9474
9475 // t.Knot (string) (string)
9476 if len("knot") > 1000000 {
9477 return xerrors.Errorf("Value in field \"knot\" was too long")
9478 }
9479
9480 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
9481 return err
9482 }
9483 if _, err := cw.WriteString(string("knot")); err != nil {
9484 return err
9485 }
9486
9487 if len(t.Knot) > 1000000 {
9488 return xerrors.Errorf("Value in field t.Knot was too long")
9489 }
9490
9491 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
9492 return err
9493 }
9494 if _, err := cw.WriteString(string(t.Knot)); err != nil {
9495 return err
9496 }
9497
9498 // t.Name (string) (string)
9499 if t.Name != nil {
9500
9501 if len("name") > 1000000 {
9502 return xerrors.Errorf("Value in field \"name\" was too long")
9503 }
9504
9505 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
9506 return err
9507 }
9508 if _, err := cw.WriteString(string("name")); err != nil {
9509 return err
9510 }
9511
9512 if t.Name == nil {
9513 if _, err := cw.Write(cbg.CborNull); err != nil {
9514 return err
9515 }
9516 } else {
9517 if len(*t.Name) > 1000000 {
9518 return xerrors.Errorf("Value in field t.Name was too long")
9519 }
9520
9521 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Name))); err != nil {
9522 return err
9523 }
9524 if _, err := cw.WriteString(string(*t.Name)); err != nil {
9525 return err
9526 }
9527 }
9528 }
9529
9530 // t.LexiconTypeID (string) (string)
9531 if len("$type") > 1000000 {
9532 return xerrors.Errorf("Value in field \"$type\" was too long")
9533 }
9534
9535 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
9536 return err
9537 }
9538 if _, err := cw.WriteString(string("$type")); err != nil {
9539 return err
9540 }
9541
9542 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil {
9543 return err
9544 }
9545 if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil {
9546 return err
9547 }
9548
9549 // t.Labels ([]string) (slice)
9550 if t.Labels != nil {
9551
9552 if len("labels") > 1000000 {
9553 return xerrors.Errorf("Value in field \"labels\" was too long")
9554 }
9555
9556 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("labels"))); err != nil {
9557 return err
9558 }
9559 if _, err := cw.WriteString(string("labels")); err != nil {
9560 return err
9561 }
9562
9563 if len(t.Labels) > 8192 {
9564 return xerrors.Errorf("Slice value in field t.Labels was too long")
9565 }
9566
9567 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Labels))); err != nil {
9568 return err
9569 }
9570 for _, v := range t.Labels {
9571 if len(v) > 1000000 {
9572 return xerrors.Errorf("Value in field v was too long")
9573 }
9574
9575 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
9576 return err
9577 }
9578 if _, err := cw.WriteString(string(v)); err != nil {
9579 return err
9580 }
9581
9582 }
9583 }
9584
9585 // t.Source (string) (string)
9586 if t.Source != nil {
9587
9588 if len("source") > 1000000 {
9589 return xerrors.Errorf("Value in field \"source\" was too long")
9590 }
9591
9592 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
9593 return err
9594 }
9595 if _, err := cw.WriteString(string("source")); err != nil {
9596 return err
9597 }
9598
9599 if t.Source == nil {
9600 if _, err := cw.Write(cbg.CborNull); err != nil {
9601 return err
9602 }
9603 } else {
9604 if len(*t.Source) > 1000000 {
9605 return xerrors.Errorf("Value in field t.Source was too long")
9606 }
9607
9608 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil {
9609 return err
9610 }
9611 if _, err := cw.WriteString(string(*t.Source)); err != nil {
9612 return err
9613 }
9614 }
9615 }
9616
9617 // t.Topics ([]string) (slice)
9618 if t.Topics != nil {
9619
9620 if len("topics") > 1000000 {
9621 return xerrors.Errorf("Value in field \"topics\" was too long")
9622 }
9623
9624 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("topics"))); err != nil {
9625 return err
9626 }
9627 if _, err := cw.WriteString(string("topics")); err != nil {
9628 return err
9629 }
9630
9631 if len(t.Topics) > 8192 {
9632 return xerrors.Errorf("Slice value in field t.Topics was too long")
9633 }
9634
9635 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Topics))); err != nil {
9636 return err
9637 }
9638 for _, v := range t.Topics {
9639 if len(v) > 1000000 {
9640 return xerrors.Errorf("Value in field v was too long")
9641 }
9642
9643 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
9644 return err
9645 }
9646 if _, err := cw.WriteString(string(v)); err != nil {
9647 return err
9648 }
9649
9650 }
9651 }
9652
9653 // t.RepoDid (string) (string)
9654 if t.RepoDid != nil {
9655
9656 if len("repoDid") > 1000000 {
9657 return xerrors.Errorf("Value in field \"repoDid\" was too long")
9658 }
9659
9660 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
9661 return err
9662 }
9663 if _, err := cw.WriteString(string("repoDid")); err != nil {
9664 return err
9665 }
9666
9667 if t.RepoDid == nil {
9668 if _, err := cw.Write(cbg.CborNull); err != nil {
9669 return err
9670 }
9671 } else {
9672 if len(*t.RepoDid) > 1000000 {
9673 return xerrors.Errorf("Value in field t.RepoDid was too long")
9674 }
9675
9676 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil {
9677 return err
9678 }
9679 if _, err := cw.WriteString(string(*t.RepoDid)); err != nil {
9680 return err
9681 }
9682 }
9683 }
9684
9685 // t.Spindle (string) (string)
9686 if t.Spindle != nil {
9687
9688 if len("spindle") > 1000000 {
9689 return xerrors.Errorf("Value in field \"spindle\" was too long")
9690 }
9691
9692 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("spindle"))); err != nil {
9693 return err
9694 }
9695 if _, err := cw.WriteString(string("spindle")); err != nil {
9696 return err
9697 }
9698
9699 if t.Spindle == nil {
9700 if _, err := cw.Write(cbg.CborNull); err != nil {
9701 return err
9702 }
9703 } else {
9704 if len(*t.Spindle) > 1000000 {
9705 return xerrors.Errorf("Value in field t.Spindle was too long")
9706 }
9707
9708 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Spindle))); err != nil {
9709 return err
9710 }
9711 if _, err := cw.WriteString(string(*t.Spindle)); err != nil {
9712 return err
9713 }
9714 }
9715 }
9716
9717 // t.Website (string) (string)
9718 if t.Website != nil {
9719
9720 if len("website") > 1000000 {
9721 return xerrors.Errorf("Value in field \"website\" was too long")
9722 }
9723
9724 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("website"))); err != nil {
9725 return err
9726 }
9727 if _, err := cw.WriteString(string("website")); err != nil {
9728 return err
9729 }
9730
9731 if t.Website == nil {
9732 if _, err := cw.Write(cbg.CborNull); err != nil {
9733 return err
9734 }
9735 } else {
9736 if len(*t.Website) > 1000000 {
9737 return xerrors.Errorf("Value in field t.Website was too long")
9738 }
9739
9740 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Website))); err != nil {
9741 return err
9742 }
9743 if _, err := cw.WriteString(string(*t.Website)); err != nil {
9744 return err
9745 }
9746 }
9747 }
9748
9749 // t.CreatedAt (string) (string)
9750 if len("createdAt") > 1000000 {
9751 return xerrors.Errorf("Value in field \"createdAt\" was too long")
9752 }
9753
9754 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
9755 return err
9756 }
9757 if _, err := cw.WriteString(string("createdAt")); err != nil {
9758 return err
9759 }
9760
9761 if len(t.CreatedAt) > 1000000 {
9762 return xerrors.Errorf("Value in field t.CreatedAt was too long")
9763 }
9764
9765 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
9766 return err
9767 }
9768 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
9769 return err
9770 }
9771
9772 // t.Description (string) (string)
9773 if t.Description != nil {
9774
9775 if len("description") > 1000000 {
9776 return xerrors.Errorf("Value in field \"description\" was too long")
9777 }
9778
9779 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
9780 return err
9781 }
9782 if _, err := cw.WriteString(string("description")); err != nil {
9783 return err
9784 }
9785
9786 if t.Description == nil {
9787 if _, err := cw.Write(cbg.CborNull); err != nil {
9788 return err
9789 }
9790 } else {
9791 if len(*t.Description) > 1000000 {
9792 return xerrors.Errorf("Value in field t.Description was too long")
9793 }
9794
9795 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
9796 return err
9797 }
9798 if _, err := cw.WriteString(string(*t.Description)); err != nil {
9799 return err
9800 }
9801 }
9802 }
9803 return nil
9804}
9805
9806func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) {
9807 *t = Repo{}
9808
9809 cr := cbg.NewCborReader(r)
9810
9811 maj, extra, err := cr.ReadHeader()
9812 if err != nil {
9813 return err
9814 }
9815 defer func() {
9816 if err == io.EOF {
9817 err = io.ErrUnexpectedEOF
9818 }
9819 }()
9820
9821 if maj != cbg.MajMap {
9822 return fmt.Errorf("cbor input should be of type map")
9823 }
9824
9825 if extra > cbg.MaxLength {
9826 return fmt.Errorf("Repo: map struct too large (%d)", extra)
9827 }
9828
9829 n := extra
9830
9831 nameBuf := make([]byte, 11)
9832 for i := uint64(0); i < n; i++ {
9833 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9834 if err != nil {
9835 return err
9836 }
9837
9838 if !ok {
9839 // Field doesn't exist on this type, so ignore it
9840 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9841 return err
9842 }
9843 continue
9844 }
9845
9846 switch string(nameBuf[:nameLen]) {
9847 // t.Knot (string) (string)
9848 case "knot":
9849
9850 {
9851 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9852 if err != nil {
9853 return err
9854 }
9855
9856 t.Knot = string(sval)
9857 }
9858 // t.Name (string) (string)
9859 case "name":
9860
9861 {
9862 b, err := cr.ReadByte()
9863 if err != nil {
9864 return err
9865 }
9866 if b != cbg.CborNull[0] {
9867 if err := cr.UnreadByte(); err != nil {
9868 return err
9869 }
9870
9871 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9872 if err != nil {
9873 return err
9874 }
9875
9876 t.Name = (*string)(&sval)
9877 }
9878 }
9879 // t.LexiconTypeID (string) (string)
9880 case "$type":
9881
9882 {
9883 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9884 if err != nil {
9885 return err
9886 }
9887
9888 t.LexiconTypeID = string(sval)
9889 }
9890 // t.Labels ([]string) (slice)
9891 case "labels":
9892
9893 maj, extra, err = cr.ReadHeader()
9894 if err != nil {
9895 return err
9896 }
9897
9898 if extra > 8192 {
9899 return fmt.Errorf("t.Labels: array too large (%d)", extra)
9900 }
9901
9902 if maj != cbg.MajArray {
9903 return fmt.Errorf("expected cbor array")
9904 }
9905
9906 if extra > 0 {
9907 t.Labels = make([]string, extra)
9908 }
9909
9910 for i := 0; i < int(extra); i++ {
9911 {
9912 var maj byte
9913 var extra uint64
9914 var err error
9915 _ = maj
9916 _ = extra
9917 _ = err
9918
9919 {
9920 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9921 if err != nil {
9922 return err
9923 }
9924
9925 t.Labels[i] = string(sval)
9926 }
9927
9928 }
9929 }
9930 // t.Source (string) (string)
9931 case "source":
9932
9933 {
9934 b, err := cr.ReadByte()
9935 if err != nil {
9936 return err
9937 }
9938 if b != cbg.CborNull[0] {
9939 if err := cr.UnreadByte(); err != nil {
9940 return err
9941 }
9942
9943 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9944 if err != nil {
9945 return err
9946 }
9947
9948 t.Source = (*string)(&sval)
9949 }
9950 }
9951 // t.Topics ([]string) (slice)
9952 case "topics":
9953
9954 maj, extra, err = cr.ReadHeader()
9955 if err != nil {
9956 return err
9957 }
9958
9959 if extra > 8192 {
9960 return fmt.Errorf("t.Topics: array too large (%d)", extra)
9961 }
9962
9963 if maj != cbg.MajArray {
9964 return fmt.Errorf("expected cbor array")
9965 }
9966
9967 if extra > 0 {
9968 t.Topics = make([]string, extra)
9969 }
9970
9971 for i := 0; i < int(extra); i++ {
9972 {
9973 var maj byte
9974 var extra uint64
9975 var err error
9976 _ = maj
9977 _ = extra
9978 _ = err
9979
9980 {
9981 sval, err := cbg.ReadStringWithMax(cr, 1000000)
9982 if err != nil {
9983 return err
9984 }
9985
9986 t.Topics[i] = string(sval)
9987 }
9988
9989 }
9990 }
9991 // t.RepoDid (string) (string)
9992 case "repoDid":
9993
9994 {
9995 b, err := cr.ReadByte()
9996 if err != nil {
9997 return err
9998 }
9999 if b != cbg.CborNull[0] {
10000 if err := cr.UnreadByte(); err != nil {
10001 return err
10002 }
10003
10004 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10005 if err != nil {
10006 return err
10007 }
10008
10009 t.RepoDid = (*string)(&sval)
10010 }
10011 }
10012 // t.Spindle (string) (string)
10013 case "spindle":
10014
10015 {
10016 b, err := cr.ReadByte()
10017 if err != nil {
10018 return err
10019 }
10020 if b != cbg.CborNull[0] {
10021 if err := cr.UnreadByte(); err != nil {
10022 return err
10023 }
10024
10025 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10026 if err != nil {
10027 return err
10028 }
10029
10030 t.Spindle = (*string)(&sval)
10031 }
10032 }
10033 // t.Website (string) (string)
10034 case "website":
10035
10036 {
10037 b, err := cr.ReadByte()
10038 if err != nil {
10039 return err
10040 }
10041 if b != cbg.CborNull[0] {
10042 if err := cr.UnreadByte(); err != nil {
10043 return err
10044 }
10045
10046 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10047 if err != nil {
10048 return err
10049 }
10050
10051 t.Website = (*string)(&sval)
10052 }
10053 }
10054 // t.CreatedAt (string) (string)
10055 case "createdAt":
10056
10057 {
10058 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10059 if err != nil {
10060 return err
10061 }
10062
10063 t.CreatedAt = string(sval)
10064 }
10065 // t.Description (string) (string)
10066 case "description":
10067
10068 {
10069 b, err := cr.ReadByte()
10070 if err != nil {
10071 return err
10072 }
10073 if b != cbg.CborNull[0] {
10074 if err := cr.UnreadByte(); err != nil {
10075 return err
10076 }
10077
10078 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10079 if err != nil {
10080 return err
10081 }
10082
10083 t.Description = (*string)(&sval)
10084 }
10085 }
10086
10087 default:
10088 // Field doesn't exist on this type, so ignore it
10089 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
10090 return err
10091 }
10092 }
10093 }
10094
10095 return nil
10096}
10097func (t *RepoArtifact) MarshalCBOR(w io.Writer) error {
10098 if t == nil {
10099 _, err := w.Write(cbg.CborNull)
10100 return err
10101 }
10102
10103 cw := cbg.NewCborWriter(w)
10104 fieldCount := 7
10105
10106 if t.Repo == nil {
10107 fieldCount--
10108 }
10109
10110 if t.RepoDid == nil {
10111 fieldCount--
10112 }
10113
10114 if t.Tag == nil {
10115 fieldCount--
10116 }
10117
10118 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
10119 return err
10120 }
10121
10122 // t.Tag (util.LexBytes) (slice)
10123 if t.Tag != nil {
10124
10125 if len("tag") > 1000000 {
10126 return xerrors.Errorf("Value in field \"tag\" was too long")
10127 }
10128
10129 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tag"))); err != nil {
10130 return err
10131 }
10132 if _, err := cw.WriteString(string("tag")); err != nil {
10133 return err
10134 }
10135
10136 if len(t.Tag) > 2097152 {
10137 return xerrors.Errorf("Byte array in field t.Tag was too long")
10138 }
10139
10140 if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Tag))); err != nil {
10141 return err
10142 }
10143
10144 if _, err := cw.Write(t.Tag); err != nil {
10145 return err
10146 }
10147
10148 }
10149
10150 // t.Name (string) (string)
10151 if len("name") > 1000000 {
10152 return xerrors.Errorf("Value in field \"name\" was too long")
10153 }
10154
10155 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
10156 return err
10157 }
10158 if _, err := cw.WriteString(string("name")); err != nil {
10159 return err
10160 }
10161
10162 if len(t.Name) > 1000000 {
10163 return xerrors.Errorf("Value in field t.Name was too long")
10164 }
10165
10166 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
10167 return err
10168 }
10169 if _, err := cw.WriteString(string(t.Name)); err != nil {
10170 return err
10171 }
10172
10173 // t.Repo (string) (string)
10174 if t.Repo != nil {
10175
10176 if len("repo") > 1000000 {
10177 return xerrors.Errorf("Value in field \"repo\" was too long")
10178 }
10179
10180 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
10181 return err
10182 }
10183 if _, err := cw.WriteString(string("repo")); err != nil {
10184 return err
10185 }
10186
10187 if t.Repo == nil {
10188 if _, err := cw.Write(cbg.CborNull); err != nil {
10189 return err
10190 }
10191 } else {
10192 if len(*t.Repo) > 1000000 {
10193 return xerrors.Errorf("Value in field t.Repo was too long")
10194 }
10195
10196 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
10197 return err
10198 }
10199 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
10200 return err
10201 }
10202 }
10203 }
10204
10205 // t.LexiconTypeID (string) (string)
10206 if len("$type") > 1000000 {
10207 return xerrors.Errorf("Value in field \"$type\" was too long")
10208 }
10209
10210 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
10211 return err
10212 }
10213 if _, err := cw.WriteString(string("$type")); err != nil {
10214 return err
10215 }
10216
10217 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.artifact"))); err != nil {
10218 return err
10219 }
10220 if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil {
10221 return err
10222 }
10223
10224 // t.RepoDid (string) (string)
10225 if t.RepoDid != nil {
10226
10227 if len("repoDid") > 1000000 {
10228 return xerrors.Errorf("Value in field \"repoDid\" was too long")
10229 }
10230
10231 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
10232 return err
10233 }
10234 if _, err := cw.WriteString(string("repoDid")); err != nil {
10235 return err
10236 }
10237
10238 if t.RepoDid == nil {
10239 if _, err := cw.Write(cbg.CborNull); err != nil {
10240 return err
10241 }
10242 } else {
10243 if len(*t.RepoDid) > 1000000 {
10244 return xerrors.Errorf("Value in field t.RepoDid was too long")
10245 }
10246
10247 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil {
10248 return err
10249 }
10250 if _, err := cw.WriteString(string(*t.RepoDid)); err != nil {
10251 return err
10252 }
10253 }
10254 }
10255
10256 // t.Artifact (util.LexBlob) (struct)
10257 if len("artifact") > 1000000 {
10258 return xerrors.Errorf("Value in field \"artifact\" was too long")
10259 }
10260
10261 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("artifact"))); err != nil {
10262 return err
10263 }
10264 if _, err := cw.WriteString(string("artifact")); err != nil {
10265 return err
10266 }
10267
10268 if err := t.Artifact.MarshalCBOR(cw); err != nil {
10269 return err
10270 }
10271
10272 // t.CreatedAt (string) (string)
10273 if len("createdAt") > 1000000 {
10274 return xerrors.Errorf("Value in field \"createdAt\" was too long")
10275 }
10276
10277 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
10278 return err
10279 }
10280 if _, err := cw.WriteString(string("createdAt")); err != nil {
10281 return err
10282 }
10283
10284 if len(t.CreatedAt) > 1000000 {
10285 return xerrors.Errorf("Value in field t.CreatedAt was too long")
10286 }
10287
10288 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
10289 return err
10290 }
10291 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
10292 return err
10293 }
10294 return nil
10295}
10296
10297func (t *RepoArtifact) UnmarshalCBOR(r io.Reader) (err error) {
10298 *t = RepoArtifact{}
10299
10300 cr := cbg.NewCborReader(r)
10301
10302 maj, extra, err := cr.ReadHeader()
10303 if err != nil {
10304 return err
10305 }
10306 defer func() {
10307 if err == io.EOF {
10308 err = io.ErrUnexpectedEOF
10309 }
10310 }()
10311
10312 if maj != cbg.MajMap {
10313 return fmt.Errorf("cbor input should be of type map")
10314 }
10315
10316 if extra > cbg.MaxLength {
10317 return fmt.Errorf("RepoArtifact: map struct too large (%d)", extra)
10318 }
10319
10320 n := extra
10321
10322 nameBuf := make([]byte, 9)
10323 for i := uint64(0); i < n; i++ {
10324 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
10325 if err != nil {
10326 return err
10327 }
10328
10329 if !ok {
10330 // Field doesn't exist on this type, so ignore it
10331 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
10332 return err
10333 }
10334 continue
10335 }
10336
10337 switch string(nameBuf[:nameLen]) {
10338 // t.Tag (util.LexBytes) (slice)
10339 case "tag":
10340
10341 maj, extra, err = cr.ReadHeader()
10342 if err != nil {
10343 return err
10344 }
10345
10346 if extra > 2097152 {
10347 return fmt.Errorf("t.Tag: byte array too large (%d)", extra)
10348 }
10349 if maj != cbg.MajByteString {
10350 return fmt.Errorf("expected byte array")
10351 }
10352
10353 if extra > 0 {
10354 t.Tag = make([]uint8, extra)
10355 }
10356
10357 if _, err := io.ReadFull(cr, t.Tag); err != nil {
10358 return err
10359 }
10360
10361 // t.Name (string) (string)
10362 case "name":
10363
10364 {
10365 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10366 if err != nil {
10367 return err
10368 }
10369
10370 t.Name = string(sval)
10371 }
10372 // t.Repo (string) (string)
10373 case "repo":
10374
10375 {
10376 b, err := cr.ReadByte()
10377 if err != nil {
10378 return err
10379 }
10380 if b != cbg.CborNull[0] {
10381 if err := cr.UnreadByte(); err != nil {
10382 return err
10383 }
10384
10385 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10386 if err != nil {
10387 return err
10388 }
10389
10390 t.Repo = (*string)(&sval)
10391 }
10392 }
10393 // t.LexiconTypeID (string) (string)
10394 case "$type":
10395
10396 {
10397 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10398 if err != nil {
10399 return err
10400 }
10401
10402 t.LexiconTypeID = string(sval)
10403 }
10404 // t.RepoDid (string) (string)
10405 case "repoDid":
10406
10407 {
10408 b, err := cr.ReadByte()
10409 if err != nil {
10410 return err
10411 }
10412 if b != cbg.CborNull[0] {
10413 if err := cr.UnreadByte(); err != nil {
10414 return err
10415 }
10416
10417 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10418 if err != nil {
10419 return err
10420 }
10421
10422 t.RepoDid = (*string)(&sval)
10423 }
10424 }
10425 // t.Artifact (util.LexBlob) (struct)
10426 case "artifact":
10427
10428 {
10429
10430 b, err := cr.ReadByte()
10431 if err != nil {
10432 return err
10433 }
10434 if b != cbg.CborNull[0] {
10435 if err := cr.UnreadByte(); err != nil {
10436 return err
10437 }
10438 t.Artifact = new(util.LexBlob)
10439 if err := t.Artifact.UnmarshalCBOR(cr); err != nil {
10440 return xerrors.Errorf("unmarshaling t.Artifact pointer: %w", err)
10441 }
10442 }
10443
10444 }
10445 // t.CreatedAt (string) (string)
10446 case "createdAt":
10447
10448 {
10449 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10450 if err != nil {
10451 return err
10452 }
10453
10454 t.CreatedAt = string(sval)
10455 }
10456
10457 default:
10458 // Field doesn't exist on this type, so ignore it
10459 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
10460 return err
10461 }
10462 }
10463 }
10464
10465 return nil
10466}
10467func (t *RepoCollaborator) MarshalCBOR(w io.Writer) error {
10468 if t == nil {
10469 _, err := w.Write(cbg.CborNull)
10470 return err
10471 }
10472
10473 cw := cbg.NewCborWriter(w)
10474
10475 if _, err := cw.Write([]byte{164}); err != nil {
10476 return err
10477 }
10478
10479 // t.Repo (string) (string)
10480 if len("repo") > 1000000 {
10481 return xerrors.Errorf("Value in field \"repo\" was too long")
10482 }
10483
10484 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
10485 return err
10486 }
10487 if _, err := cw.WriteString(string("repo")); err != nil {
10488 return err
10489 }
10490
10491 if len(t.Repo) > 1000000 {
10492 return xerrors.Errorf("Value in field t.Repo was too long")
10493 }
10494
10495 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
10496 return err
10497 }
10498 if _, err := cw.WriteString(string(t.Repo)); err != nil {
10499 return err
10500 }
10501
10502 // t.LexiconTypeID (string) (string)
10503 if len("$type") > 1000000 {
10504 return xerrors.Errorf("Value in field \"$type\" was too long")
10505 }
10506
10507 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
10508 return err
10509 }
10510 if _, err := cw.WriteString(string("$type")); err != nil {
10511 return err
10512 }
10513
10514 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.collaborator"))); err != nil {
10515 return err
10516 }
10517 if _, err := cw.WriteString(string("sh.tangled.repo.collaborator")); err != nil {
10518 return err
10519 }
10520
10521 // t.Subject (string) (string)
10522 if len("subject") > 1000000 {
10523 return xerrors.Errorf("Value in field \"subject\" was too long")
10524 }
10525
10526 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
10527 return err
10528 }
10529 if _, err := cw.WriteString(string("subject")); err != nil {
10530 return err
10531 }
10532
10533 if len(t.Subject) > 1000000 {
10534 return xerrors.Errorf("Value in field t.Subject was too long")
10535 }
10536
10537 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
10538 return err
10539 }
10540 if _, err := cw.WriteString(string(t.Subject)); err != nil {
10541 return err
10542 }
10543
10544 // t.CreatedAt (string) (string)
10545 if len("createdAt") > 1000000 {
10546 return xerrors.Errorf("Value in field \"createdAt\" was too long")
10547 }
10548
10549 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
10550 return err
10551 }
10552 if _, err := cw.WriteString(string("createdAt")); err != nil {
10553 return err
10554 }
10555
10556 if len(t.CreatedAt) > 1000000 {
10557 return xerrors.Errorf("Value in field t.CreatedAt was too long")
10558 }
10559
10560 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
10561 return err
10562 }
10563 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
10564 return err
10565 }
10566 return nil
10567}
10568
10569func (t *RepoCollaborator) UnmarshalCBOR(r io.Reader) (err error) {
10570 *t = RepoCollaborator{}
10571
10572 cr := cbg.NewCborReader(r)
10573
10574 maj, extra, err := cr.ReadHeader()
10575 if err != nil {
10576 return err
10577 }
10578 defer func() {
10579 if err == io.EOF {
10580 err = io.ErrUnexpectedEOF
10581 }
10582 }()
10583
10584 if maj != cbg.MajMap {
10585 return fmt.Errorf("cbor input should be of type map")
10586 }
10587
10588 if extra > cbg.MaxLength {
10589 return fmt.Errorf("RepoCollaborator: map struct too large (%d)", extra)
10590 }
10591
10592 n := extra
10593
10594 nameBuf := make([]byte, 9)
10595 for i := uint64(0); i < n; i++ {
10596 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
10597 if err != nil {
10598 return err
10599 }
10600
10601 if !ok {
10602 // Field doesn't exist on this type, so ignore it
10603 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
10604 return err
10605 }
10606 continue
10607 }
10608
10609 switch string(nameBuf[:nameLen]) {
10610 // t.Repo (string) (string)
10611 case "repo":
10612
10613 {
10614 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10615 if err != nil {
10616 return err
10617 }
10618
10619 t.Repo = string(sval)
10620 }
10621 // t.LexiconTypeID (string) (string)
10622 case "$type":
10623
10624 {
10625 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10626 if err != nil {
10627 return err
10628 }
10629
10630 t.LexiconTypeID = string(sval)
10631 }
10632 // t.Subject (string) (string)
10633 case "subject":
10634
10635 {
10636 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10637 if err != nil {
10638 return err
10639 }
10640
10641 t.Subject = string(sval)
10642 }
10643 // t.CreatedAt (string) (string)
10644 case "createdAt":
10645
10646 {
10647 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10648 if err != nil {
10649 return err
10650 }
10651
10652 t.CreatedAt = string(sval)
10653 }
10654
10655 default:
10656 // Field doesn't exist on this type, so ignore it
10657 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
10658 return err
10659 }
10660 }
10661 }
10662
10663 return nil
10664}
10665func (t *RepoIssue) MarshalCBOR(w io.Writer) error {
10666 if t == nil {
10667 _, err := w.Write(cbg.CborNull)
10668 return err
10669 }
10670
10671 cw := cbg.NewCborWriter(w)
10672 fieldCount := 7
10673
10674 if t.Body == nil {
10675 fieldCount--
10676 }
10677
10678 if t.Mentions == nil {
10679 fieldCount--
10680 }
10681
10682 if t.References == nil {
10683 fieldCount--
10684 }
10685
10686 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
10687 return err
10688 }
10689
10690 // t.Body (string) (string)
10691 if t.Body != nil {
10692
10693 if len("body") > 1000000 {
10694 return xerrors.Errorf("Value in field \"body\" was too long")
10695 }
10696
10697 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
10698 return err
10699 }
10700 if _, err := cw.WriteString(string("body")); err != nil {
10701 return err
10702 }
10703
10704 if t.Body == nil {
10705 if _, err := cw.Write(cbg.CborNull); err != nil {
10706 return err
10707 }
10708 } else {
10709 if len(*t.Body) > 1000000 {
10710 return xerrors.Errorf("Value in field t.Body was too long")
10711 }
10712
10713 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
10714 return err
10715 }
10716 if _, err := cw.WriteString(string(*t.Body)); err != nil {
10717 return err
10718 }
10719 }
10720 }
10721
10722 // t.Repo (string) (string)
10723 if len("repo") > 1000000 {
10724 return xerrors.Errorf("Value in field \"repo\" was too long")
10725 }
10726
10727 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
10728 return err
10729 }
10730 if _, err := cw.WriteString(string("repo")); err != nil {
10731 return err
10732 }
10733
10734 if len(t.Repo) > 1000000 {
10735 return xerrors.Errorf("Value in field t.Repo was too long")
10736 }
10737
10738 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
10739 return err
10740 }
10741 if _, err := cw.WriteString(string(t.Repo)); err != nil {
10742 return err
10743 }
10744
10745 // t.LexiconTypeID (string) (string)
10746 if len("$type") > 1000000 {
10747 return xerrors.Errorf("Value in field \"$type\" was too long")
10748 }
10749
10750 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
10751 return err
10752 }
10753 if _, err := cw.WriteString(string("$type")); err != nil {
10754 return err
10755 }
10756
10757 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil {
10758 return err
10759 }
10760 if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil {
10761 return err
10762 }
10763
10764 // t.Title (string) (string)
10765 if len("title") > 1000000 {
10766 return xerrors.Errorf("Value in field \"title\" was too long")
10767 }
10768
10769 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
10770 return err
10771 }
10772 if _, err := cw.WriteString(string("title")); err != nil {
10773 return err
10774 }
10775
10776 if len(t.Title) > 1000000 {
10777 return xerrors.Errorf("Value in field t.Title was too long")
10778 }
10779
10780 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
10781 return err
10782 }
10783 if _, err := cw.WriteString(string(t.Title)); err != nil {
10784 return err
10785 }
10786
10787 // t.Mentions ([]string) (slice)
10788 if t.Mentions != nil {
10789
10790 if len("mentions") > 1000000 {
10791 return xerrors.Errorf("Value in field \"mentions\" was too long")
10792 }
10793
10794 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
10795 return err
10796 }
10797 if _, err := cw.WriteString(string("mentions")); err != nil {
10798 return err
10799 }
10800
10801 if len(t.Mentions) > 8192 {
10802 return xerrors.Errorf("Slice value in field t.Mentions was too long")
10803 }
10804
10805 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
10806 return err
10807 }
10808 for _, v := range t.Mentions {
10809 if len(v) > 1000000 {
10810 return xerrors.Errorf("Value in field v was too long")
10811 }
10812
10813 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
10814 return err
10815 }
10816 if _, err := cw.WriteString(string(v)); err != nil {
10817 return err
10818 }
10819
10820 }
10821 }
10822
10823 // t.CreatedAt (string) (string)
10824 if len("createdAt") > 1000000 {
10825 return xerrors.Errorf("Value in field \"createdAt\" was too long")
10826 }
10827
10828 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
10829 return err
10830 }
10831 if _, err := cw.WriteString(string("createdAt")); err != nil {
10832 return err
10833 }
10834
10835 if len(t.CreatedAt) > 1000000 {
10836 return xerrors.Errorf("Value in field t.CreatedAt was too long")
10837 }
10838
10839 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
10840 return err
10841 }
10842 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
10843 return err
10844 }
10845
10846 // t.References ([]string) (slice)
10847 if t.References != nil {
10848
10849 if len("references") > 1000000 {
10850 return xerrors.Errorf("Value in field \"references\" was too long")
10851 }
10852
10853 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
10854 return err
10855 }
10856 if _, err := cw.WriteString(string("references")); err != nil {
10857 return err
10858 }
10859
10860 if len(t.References) > 8192 {
10861 return xerrors.Errorf("Slice value in field t.References was too long")
10862 }
10863
10864 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
10865 return err
10866 }
10867 for _, v := range t.References {
10868 if len(v) > 1000000 {
10869 return xerrors.Errorf("Value in field v was too long")
10870 }
10871
10872 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
10873 return err
10874 }
10875 if _, err := cw.WriteString(string(v)); err != nil {
10876 return err
10877 }
10878
10879 }
10880 }
10881 return nil
10882}
10883
10884func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) {
10885 *t = RepoIssue{}
10886
10887 cr := cbg.NewCborReader(r)
10888
10889 maj, extra, err := cr.ReadHeader()
10890 if err != nil {
10891 return err
10892 }
10893 defer func() {
10894 if err == io.EOF {
10895 err = io.ErrUnexpectedEOF
10896 }
10897 }()
10898
10899 if maj != cbg.MajMap {
10900 return fmt.Errorf("cbor input should be of type map")
10901 }
10902
10903 if extra > cbg.MaxLength {
10904 return fmt.Errorf("RepoIssue: map struct too large (%d)", extra)
10905 }
10906
10907 n := extra
10908
10909 nameBuf := make([]byte, 10)
10910 for i := uint64(0); i < n; i++ {
10911 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
10912 if err != nil {
10913 return err
10914 }
10915
10916 if !ok {
10917 // Field doesn't exist on this type, so ignore it
10918 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
10919 return err
10920 }
10921 continue
10922 }
10923
10924 switch string(nameBuf[:nameLen]) {
10925 // t.Body (string) (string)
10926 case "body":
10927
10928 {
10929 b, err := cr.ReadByte()
10930 if err != nil {
10931 return err
10932 }
10933 if b != cbg.CborNull[0] {
10934 if err := cr.UnreadByte(); err != nil {
10935 return err
10936 }
10937
10938 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10939 if err != nil {
10940 return err
10941 }
10942
10943 t.Body = (*string)(&sval)
10944 }
10945 }
10946 // t.Repo (string) (string)
10947 case "repo":
10948
10949 {
10950 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10951 if err != nil {
10952 return err
10953 }
10954
10955 t.Repo = string(sval)
10956 }
10957 // t.LexiconTypeID (string) (string)
10958 case "$type":
10959
10960 {
10961 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10962 if err != nil {
10963 return err
10964 }
10965
10966 t.LexiconTypeID = string(sval)
10967 }
10968 // t.Title (string) (string)
10969 case "title":
10970
10971 {
10972 sval, err := cbg.ReadStringWithMax(cr, 1000000)
10973 if err != nil {
10974 return err
10975 }
10976
10977 t.Title = string(sval)
10978 }
10979 // t.Mentions ([]string) (slice)
10980 case "mentions":
10981
10982 maj, extra, err = cr.ReadHeader()
10983 if err != nil {
10984 return err
10985 }
10986
10987 if extra > 8192 {
10988 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
10989 }
10990
10991 if maj != cbg.MajArray {
10992 return fmt.Errorf("expected cbor array")
10993 }
10994
10995 if extra > 0 {
10996 t.Mentions = make([]string, extra)
10997 }
10998
10999 for i := 0; i < int(extra); i++ {
11000 {
11001 var maj byte
11002 var extra uint64
11003 var err error
11004 _ = maj
11005 _ = extra
11006 _ = err
11007
11008 {
11009 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11010 if err != nil {
11011 return err
11012 }
11013
11014 t.Mentions[i] = string(sval)
11015 }
11016
11017 }
11018 }
11019 // t.CreatedAt (string) (string)
11020 case "createdAt":
11021
11022 {
11023 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11024 if err != nil {
11025 return err
11026 }
11027
11028 t.CreatedAt = string(sval)
11029 }
11030 // t.References ([]string) (slice)
11031 case "references":
11032
11033 maj, extra, err = cr.ReadHeader()
11034 if err != nil {
11035 return err
11036 }
11037
11038 if extra > 8192 {
11039 return fmt.Errorf("t.References: array too large (%d)", extra)
11040 }
11041
11042 if maj != cbg.MajArray {
11043 return fmt.Errorf("expected cbor array")
11044 }
11045
11046 if extra > 0 {
11047 t.References = make([]string, extra)
11048 }
11049
11050 for i := 0; i < int(extra); i++ {
11051 {
11052 var maj byte
11053 var extra uint64
11054 var err error
11055 _ = maj
11056 _ = extra
11057 _ = err
11058
11059 {
11060 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11061 if err != nil {
11062 return err
11063 }
11064
11065 t.References[i] = string(sval)
11066 }
11067
11068 }
11069 }
11070
11071 default:
11072 // Field doesn't exist on this type, so ignore it
11073 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
11074 return err
11075 }
11076 }
11077 }
11078
11079 return nil
11080}
11081func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error {
11082 if t == nil {
11083 _, err := w.Write(cbg.CborNull)
11084 return err
11085 }
11086
11087 cw := cbg.NewCborWriter(w)
11088 fieldCount := 7
11089
11090 if t.Mentions == nil {
11091 fieldCount--
11092 }
11093
11094 if t.References == nil {
11095 fieldCount--
11096 }
11097
11098 if t.ReplyTo == nil {
11099 fieldCount--
11100 }
11101
11102 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
11103 return err
11104 }
11105
11106 // t.Body (string) (string)
11107 if len("body") > 1000000 {
11108 return xerrors.Errorf("Value in field \"body\" was too long")
11109 }
11110
11111 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
11112 return err
11113 }
11114 if _, err := cw.WriteString(string("body")); err != nil {
11115 return err
11116 }
11117
11118 if len(t.Body) > 1000000 {
11119 return xerrors.Errorf("Value in field t.Body was too long")
11120 }
11121
11122 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
11123 return err
11124 }
11125 if _, err := cw.WriteString(string(t.Body)); err != nil {
11126 return err
11127 }
11128
11129 // t.LexiconTypeID (string) (string)
11130 if len("$type") > 1000000 {
11131 return xerrors.Errorf("Value in field \"$type\" was too long")
11132 }
11133
11134 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
11135 return err
11136 }
11137 if _, err := cw.WriteString(string("$type")); err != nil {
11138 return err
11139 }
11140
11141 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil {
11142 return err
11143 }
11144 if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil {
11145 return err
11146 }
11147
11148 // t.Issue (string) (string)
11149 if len("issue") > 1000000 {
11150 return xerrors.Errorf("Value in field \"issue\" was too long")
11151 }
11152
11153 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
11154 return err
11155 }
11156 if _, err := cw.WriteString(string("issue")); err != nil {
11157 return err
11158 }
11159
11160 if len(t.Issue) > 1000000 {
11161 return xerrors.Errorf("Value in field t.Issue was too long")
11162 }
11163
11164 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
11165 return err
11166 }
11167 if _, err := cw.WriteString(string(t.Issue)); err != nil {
11168 return err
11169 }
11170
11171 // t.ReplyTo (string) (string)
11172 if t.ReplyTo != nil {
11173
11174 if len("replyTo") > 1000000 {
11175 return xerrors.Errorf("Value in field \"replyTo\" was too long")
11176 }
11177
11178 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("replyTo"))); err != nil {
11179 return err
11180 }
11181 if _, err := cw.WriteString(string("replyTo")); err != nil {
11182 return err
11183 }
11184
11185 if t.ReplyTo == nil {
11186 if _, err := cw.Write(cbg.CborNull); err != nil {
11187 return err
11188 }
11189 } else {
11190 if len(*t.ReplyTo) > 1000000 {
11191 return xerrors.Errorf("Value in field t.ReplyTo was too long")
11192 }
11193
11194 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ReplyTo))); err != nil {
11195 return err
11196 }
11197 if _, err := cw.WriteString(string(*t.ReplyTo)); err != nil {
11198 return err
11199 }
11200 }
11201 }
11202
11203 // t.Mentions ([]string) (slice)
11204 if t.Mentions != nil {
11205
11206 if len("mentions") > 1000000 {
11207 return xerrors.Errorf("Value in field \"mentions\" was too long")
11208 }
11209
11210 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
11211 return err
11212 }
11213 if _, err := cw.WriteString(string("mentions")); err != nil {
11214 return err
11215 }
11216
11217 if len(t.Mentions) > 8192 {
11218 return xerrors.Errorf("Slice value in field t.Mentions was too long")
11219 }
11220
11221 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
11222 return err
11223 }
11224 for _, v := range t.Mentions {
11225 if len(v) > 1000000 {
11226 return xerrors.Errorf("Value in field v was too long")
11227 }
11228
11229 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
11230 return err
11231 }
11232 if _, err := cw.WriteString(string(v)); err != nil {
11233 return err
11234 }
11235
11236 }
11237 }
11238
11239 // t.CreatedAt (string) (string)
11240 if len("createdAt") > 1000000 {
11241 return xerrors.Errorf("Value in field \"createdAt\" was too long")
11242 }
11243
11244 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
11245 return err
11246 }
11247 if _, err := cw.WriteString(string("createdAt")); err != nil {
11248 return err
11249 }
11250
11251 if len(t.CreatedAt) > 1000000 {
11252 return xerrors.Errorf("Value in field t.CreatedAt was too long")
11253 }
11254
11255 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
11256 return err
11257 }
11258 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
11259 return err
11260 }
11261
11262 // t.References ([]string) (slice)
11263 if t.References != nil {
11264
11265 if len("references") > 1000000 {
11266 return xerrors.Errorf("Value in field \"references\" was too long")
11267 }
11268
11269 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
11270 return err
11271 }
11272 if _, err := cw.WriteString(string("references")); err != nil {
11273 return err
11274 }
11275
11276 if len(t.References) > 8192 {
11277 return xerrors.Errorf("Slice value in field t.References was too long")
11278 }
11279
11280 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
11281 return err
11282 }
11283 for _, v := range t.References {
11284 if len(v) > 1000000 {
11285 return xerrors.Errorf("Value in field v was too long")
11286 }
11287
11288 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
11289 return err
11290 }
11291 if _, err := cw.WriteString(string(v)); err != nil {
11292 return err
11293 }
11294
11295 }
11296 }
11297 return nil
11298}
11299
11300func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) {
11301 *t = RepoIssueComment{}
11302
11303 cr := cbg.NewCborReader(r)
11304
11305 maj, extra, err := cr.ReadHeader()
11306 if err != nil {
11307 return err
11308 }
11309 defer func() {
11310 if err == io.EOF {
11311 err = io.ErrUnexpectedEOF
11312 }
11313 }()
11314
11315 if maj != cbg.MajMap {
11316 return fmt.Errorf("cbor input should be of type map")
11317 }
11318
11319 if extra > cbg.MaxLength {
11320 return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra)
11321 }
11322
11323 n := extra
11324
11325 nameBuf := make([]byte, 10)
11326 for i := uint64(0); i < n; i++ {
11327 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
11328 if err != nil {
11329 return err
11330 }
11331
11332 if !ok {
11333 // Field doesn't exist on this type, so ignore it
11334 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
11335 return err
11336 }
11337 continue
11338 }
11339
11340 switch string(nameBuf[:nameLen]) {
11341 // t.Body (string) (string)
11342 case "body":
11343
11344 {
11345 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11346 if err != nil {
11347 return err
11348 }
11349
11350 t.Body = string(sval)
11351 }
11352 // t.LexiconTypeID (string) (string)
11353 case "$type":
11354
11355 {
11356 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11357 if err != nil {
11358 return err
11359 }
11360
11361 t.LexiconTypeID = string(sval)
11362 }
11363 // t.Issue (string) (string)
11364 case "issue":
11365
11366 {
11367 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11368 if err != nil {
11369 return err
11370 }
11371
11372 t.Issue = string(sval)
11373 }
11374 // t.ReplyTo (string) (string)
11375 case "replyTo":
11376
11377 {
11378 b, err := cr.ReadByte()
11379 if err != nil {
11380 return err
11381 }
11382 if b != cbg.CborNull[0] {
11383 if err := cr.UnreadByte(); err != nil {
11384 return err
11385 }
11386
11387 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11388 if err != nil {
11389 return err
11390 }
11391
11392 t.ReplyTo = (*string)(&sval)
11393 }
11394 }
11395 // t.Mentions ([]string) (slice)
11396 case "mentions":
11397
11398 maj, extra, err = cr.ReadHeader()
11399 if err != nil {
11400 return err
11401 }
11402
11403 if extra > 8192 {
11404 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
11405 }
11406
11407 if maj != cbg.MajArray {
11408 return fmt.Errorf("expected cbor array")
11409 }
11410
11411 if extra > 0 {
11412 t.Mentions = make([]string, extra)
11413 }
11414
11415 for i := 0; i < int(extra); i++ {
11416 {
11417 var maj byte
11418 var extra uint64
11419 var err error
11420 _ = maj
11421 _ = extra
11422 _ = err
11423
11424 {
11425 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11426 if err != nil {
11427 return err
11428 }
11429
11430 t.Mentions[i] = string(sval)
11431 }
11432
11433 }
11434 }
11435 // t.CreatedAt (string) (string)
11436 case "createdAt":
11437
11438 {
11439 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11440 if err != nil {
11441 return err
11442 }
11443
11444 t.CreatedAt = string(sval)
11445 }
11446 // t.References ([]string) (slice)
11447 case "references":
11448
11449 maj, extra, err = cr.ReadHeader()
11450 if err != nil {
11451 return err
11452 }
11453
11454 if extra > 8192 {
11455 return fmt.Errorf("t.References: array too large (%d)", extra)
11456 }
11457
11458 if maj != cbg.MajArray {
11459 return fmt.Errorf("expected cbor array")
11460 }
11461
11462 if extra > 0 {
11463 t.References = make([]string, extra)
11464 }
11465
11466 for i := 0; i < int(extra); i++ {
11467 {
11468 var maj byte
11469 var extra uint64
11470 var err error
11471 _ = maj
11472 _ = extra
11473 _ = err
11474
11475 {
11476 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11477 if err != nil {
11478 return err
11479 }
11480
11481 t.References[i] = string(sval)
11482 }
11483
11484 }
11485 }
11486
11487 default:
11488 // Field doesn't exist on this type, so ignore it
11489 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
11490 return err
11491 }
11492 }
11493 }
11494
11495 return nil
11496}
11497func (t *RepoIssueState) MarshalCBOR(w io.Writer) error {
11498 if t == nil {
11499 _, err := w.Write(cbg.CborNull)
11500 return err
11501 }
11502
11503 cw := cbg.NewCborWriter(w)
11504
11505 if _, err := cw.Write([]byte{163}); err != nil {
11506 return err
11507 }
11508
11509 // t.LexiconTypeID (string) (string)
11510 if len("$type") > 1000000 {
11511 return xerrors.Errorf("Value in field \"$type\" was too long")
11512 }
11513
11514 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
11515 return err
11516 }
11517 if _, err := cw.WriteString(string("$type")); err != nil {
11518 return err
11519 }
11520
11521 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil {
11522 return err
11523 }
11524 if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil {
11525 return err
11526 }
11527
11528 // t.Issue (string) (string)
11529 if len("issue") > 1000000 {
11530 return xerrors.Errorf("Value in field \"issue\" was too long")
11531 }
11532
11533 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
11534 return err
11535 }
11536 if _, err := cw.WriteString(string("issue")); err != nil {
11537 return err
11538 }
11539
11540 if len(t.Issue) > 1000000 {
11541 return xerrors.Errorf("Value in field t.Issue was too long")
11542 }
11543
11544 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
11545 return err
11546 }
11547 if _, err := cw.WriteString(string(t.Issue)); err != nil {
11548 return err
11549 }
11550
11551 // t.State (string) (string)
11552 if len("state") > 1000000 {
11553 return xerrors.Errorf("Value in field \"state\" was too long")
11554 }
11555
11556 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil {
11557 return err
11558 }
11559 if _, err := cw.WriteString(string("state")); err != nil {
11560 return err
11561 }
11562
11563 if len(t.State) > 1000000 {
11564 return xerrors.Errorf("Value in field t.State was too long")
11565 }
11566
11567 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil {
11568 return err
11569 }
11570 if _, err := cw.WriteString(string(t.State)); err != nil {
11571 return err
11572 }
11573 return nil
11574}
11575
11576func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) {
11577 *t = RepoIssueState{}
11578
11579 cr := cbg.NewCborReader(r)
11580
11581 maj, extra, err := cr.ReadHeader()
11582 if err != nil {
11583 return err
11584 }
11585 defer func() {
11586 if err == io.EOF {
11587 err = io.ErrUnexpectedEOF
11588 }
11589 }()
11590
11591 if maj != cbg.MajMap {
11592 return fmt.Errorf("cbor input should be of type map")
11593 }
11594
11595 if extra > cbg.MaxLength {
11596 return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra)
11597 }
11598
11599 n := extra
11600
11601 nameBuf := make([]byte, 5)
11602 for i := uint64(0); i < n; i++ {
11603 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
11604 if err != nil {
11605 return err
11606 }
11607
11608 if !ok {
11609 // Field doesn't exist on this type, so ignore it
11610 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
11611 return err
11612 }
11613 continue
11614 }
11615
11616 switch string(nameBuf[:nameLen]) {
11617 // t.LexiconTypeID (string) (string)
11618 case "$type":
11619
11620 {
11621 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11622 if err != nil {
11623 return err
11624 }
11625
11626 t.LexiconTypeID = string(sval)
11627 }
11628 // t.Issue (string) (string)
11629 case "issue":
11630
11631 {
11632 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11633 if err != nil {
11634 return err
11635 }
11636
11637 t.Issue = string(sval)
11638 }
11639 // t.State (string) (string)
11640 case "state":
11641
11642 {
11643 sval, err := cbg.ReadStringWithMax(cr, 1000000)
11644 if err != nil {
11645 return err
11646 }
11647
11648 t.State = string(sval)
11649 }
11650
11651 default:
11652 // Field doesn't exist on this type, so ignore it
11653 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
11654 return err
11655 }
11656 }
11657 }
11658
11659 return nil
11660}
11661func (t *RepoPull) MarshalCBOR(w io.Writer) error {
11662 if t == nil {
11663 _, err := w.Write(cbg.CborNull)
11664 return err
11665 }
11666
11667 cw := cbg.NewCborWriter(w)
11668 fieldCount := 10
11669
11670 if t.Body == nil {
11671 fieldCount--
11672 }
11673
11674 if t.DependentOn == nil {
11675 fieldCount--
11676 }
11677
11678 if t.Mentions == nil {
11679 fieldCount--
11680 }
11681
11682 if t.References == nil {
11683 fieldCount--
11684 }
11685
11686 if t.Source == nil {
11687 fieldCount--
11688 }
11689
11690 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
11691 return err
11692 }
11693
11694 // t.Body (string) (string)
11695 if t.Body != nil {
11696
11697 if len("body") > 1000000 {
11698 return xerrors.Errorf("Value in field \"body\" was too long")
11699 }
11700
11701 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
11702 return err
11703 }
11704 if _, err := cw.WriteString(string("body")); err != nil {
11705 return err
11706 }
11707
11708 if t.Body == nil {
11709 if _, err := cw.Write(cbg.CborNull); err != nil {
11710 return err
11711 }
11712 } else {
11713 if len(*t.Body) > 1000000 {
11714 return xerrors.Errorf("Value in field t.Body was too long")
11715 }
11716
11717 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
11718 return err
11719 }
11720 if _, err := cw.WriteString(string(*t.Body)); err != nil {
11721 return err
11722 }
11723 }
11724 }
11725
11726 // t.LexiconTypeID (string) (string)
11727 if len("$type") > 1000000 {
11728 return xerrors.Errorf("Value in field \"$type\" was too long")
11729 }
11730
11731 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
11732 return err
11733 }
11734 if _, err := cw.WriteString(string("$type")); err != nil {
11735 return err
11736 }
11737
11738 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil {
11739 return err
11740 }
11741 if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil {
11742 return err
11743 }
11744
11745 // t.Title (string) (string)
11746 if len("title") > 1000000 {
11747 return xerrors.Errorf("Value in field \"title\" was too long")
11748 }
11749
11750 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
11751 return err
11752 }
11753 if _, err := cw.WriteString(string("title")); err != nil {
11754 return err
11755 }
11756
11757 if len(t.Title) > 1000000 {
11758 return xerrors.Errorf("Value in field t.Title was too long")
11759 }
11760
11761 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
11762 return err
11763 }
11764 if _, err := cw.WriteString(string(t.Title)); err != nil {
11765 return err
11766 }
11767
11768 // t.Rounds ([]*tangled.RepoPull_Round) (slice)
11769 if len("rounds") > 1000000 {
11770 return xerrors.Errorf("Value in field \"rounds\" was too long")
11771 }
11772
11773 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("rounds"))); err != nil {
11774 return err
11775 }
11776 if _, err := cw.WriteString(string("rounds")); err != nil {
11777 return err
11778 }
11779
11780 if len(t.Rounds) > 8192 {
11781 return xerrors.Errorf("Slice value in field t.Rounds was too long")
11782 }
11783
11784 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Rounds))); err != nil {
11785 return err
11786 }
11787 for _, v := range t.Rounds {
11788 if err := v.MarshalCBOR(cw); err != nil {
11789 return err
11790 }
11791
11792 }
11793
11794 // t.Source (tangled.RepoPull_Source) (struct)
11795 if t.Source != nil {
11796
11797 if len("source") > 1000000 {
11798 return xerrors.Errorf("Value in field \"source\" was too long")
11799 }
11800
11801 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
11802 return err
11803 }
11804 if _, err := cw.WriteString(string("source")); err != nil {
11805 return err
11806 }
11807
11808 if err := t.Source.MarshalCBOR(cw); err != nil {
11809 return err
11810 }
11811 }
11812
11813 // t.Target (tangled.RepoPull_Target) (struct)
11814 if len("target") > 1000000 {
11815 return xerrors.Errorf("Value in field \"target\" was too long")
11816 }
11817
11818 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("target"))); err != nil {
11819 return err
11820 }
11821 if _, err := cw.WriteString(string("target")); err != nil {
11822 return err
11823 }
11824
11825 if err := t.Target.MarshalCBOR(cw); err != nil {
11826 return err
11827 }
11828
11829 // t.Mentions ([]string) (slice)
11830 if t.Mentions != nil {
11831
11832 if len("mentions") > 1000000 {
11833 return xerrors.Errorf("Value in field \"mentions\" was too long")
11834 }
11835
11836 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
11837 return err
11838 }
11839 if _, err := cw.WriteString(string("mentions")); err != nil {
11840 return err
11841 }
11842
11843 if len(t.Mentions) > 8192 {
11844 return xerrors.Errorf("Slice value in field t.Mentions was too long")
11845 }
11846
11847 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
11848 return err
11849 }
11850 for _, v := range t.Mentions {
11851 if len(v) > 1000000 {
11852 return xerrors.Errorf("Value in field v was too long")
11853 }
11854
11855 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
11856 return err
11857 }
11858 if _, err := cw.WriteString(string(v)); err != nil {
11859 return err
11860 }
11861
11862 }
11863 }
11864
11865 // t.CreatedAt (string) (string)
11866 if len("createdAt") > 1000000 {
11867 return xerrors.Errorf("Value in field \"createdAt\" was too long")
11868 }
11869
11870 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
11871 return err
11872 }
11873 if _, err := cw.WriteString(string("createdAt")); err != nil {
11874 return err
11875 }
11876
11877 if len(t.CreatedAt) > 1000000 {
11878 return xerrors.Errorf("Value in field t.CreatedAt was too long")
11879 }
11880
11881 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
11882 return err
11883 }
11884 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
11885 return err
11886 }
11887
11888 // t.References ([]string) (slice)
11889 if t.References != nil {
11890
11891 if len("references") > 1000000 {
11892 return xerrors.Errorf("Value in field \"references\" was too long")
11893 }
11894
11895 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
11896 return err
11897 }
11898 if _, err := cw.WriteString(string("references")); err != nil {
11899 return err
11900 }
11901
11902 if len(t.References) > 8192 {
11903 return xerrors.Errorf("Slice value in field t.References was too long")
11904 }
11905
11906 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
11907 return err
11908 }
11909 for _, v := range t.References {
11910 if len(v) > 1000000 {
11911 return xerrors.Errorf("Value in field v was too long")
11912 }
11913
11914 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
11915 return err
11916 }
11917 if _, err := cw.WriteString(string(v)); err != nil {
11918 return err
11919 }
11920
11921 }
11922 }
11923
11924 // t.DependentOn (string) (string)
11925 if t.DependentOn != nil {
11926
11927 if len("dependentOn") > 1000000 {
11928 return xerrors.Errorf("Value in field \"dependentOn\" was too long")
11929 }
11930
11931 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("dependentOn"))); err != nil {
11932 return err
11933 }
11934 if _, err := cw.WriteString(string("dependentOn")); err != nil {
11935 return err
11936 }
11937
11938 if t.DependentOn == nil {
11939 if _, err := cw.Write(cbg.CborNull); err != nil {
11940 return err
11941 }
11942 } else {
11943 if len(*t.DependentOn) > 1000000 {
11944 return xerrors.Errorf("Value in field t.DependentOn was too long")
11945 }
11946
11947 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.DependentOn))); err != nil {
11948 return err
11949 }
11950 if _, err := cw.WriteString(string(*t.DependentOn)); err != nil {
11951 return err
11952 }
11953 }
11954 }
11955 return nil
11956}
11957
11958func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) {
11959 *t = RepoPull{}
11960
11961 cr := cbg.NewCborReader(r)
11962
11963 maj, extra, err := cr.ReadHeader()
11964 if err != nil {
11965 return err
11966 }
11967 defer func() {
11968 if err == io.EOF {
11969 err = io.ErrUnexpectedEOF
11970 }
11971 }()
11972
11973 if maj != cbg.MajMap {
11974 return fmt.Errorf("cbor input should be of type map")
11975 }
11976
11977 if extra > cbg.MaxLength {
11978 return fmt.Errorf("RepoPull: map struct too large (%d)", extra)
11979 }
11980
11981 n := extra
11982
11983 nameBuf := make([]byte, 11)
11984 for i := uint64(0); i < n; i++ {
11985 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
11986 if err != nil {
11987 return err
11988 }
11989
11990 if !ok {
11991 // Field doesn't exist on this type, so ignore it
11992 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
11993 return err
11994 }
11995 continue
11996 }
11997
11998 switch string(nameBuf[:nameLen]) {
11999 // t.Body (string) (string)
12000 case "body":
12001
12002 {
12003 b, err := cr.ReadByte()
12004 if err != nil {
12005 return err
12006 }
12007 if b != cbg.CborNull[0] {
12008 if err := cr.UnreadByte(); err != nil {
12009 return err
12010 }
12011
12012 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12013 if err != nil {
12014 return err
12015 }
12016
12017 t.Body = (*string)(&sval)
12018 }
12019 }
12020 // t.LexiconTypeID (string) (string)
12021 case "$type":
12022
12023 {
12024 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12025 if err != nil {
12026 return err
12027 }
12028
12029 t.LexiconTypeID = string(sval)
12030 }
12031 // t.Title (string) (string)
12032 case "title":
12033
12034 {
12035 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12036 if err != nil {
12037 return err
12038 }
12039
12040 t.Title = string(sval)
12041 }
12042 // t.Rounds ([]*tangled.RepoPull_Round) (slice)
12043 case "rounds":
12044
12045 maj, extra, err = cr.ReadHeader()
12046 if err != nil {
12047 return err
12048 }
12049
12050 if extra > 8192 {
12051 return fmt.Errorf("t.Rounds: array too large (%d)", extra)
12052 }
12053
12054 if maj != cbg.MajArray {
12055 return fmt.Errorf("expected cbor array")
12056 }
12057
12058 if extra > 0 {
12059 t.Rounds = make([]*RepoPull_Round, extra)
12060 }
12061
12062 for i := 0; i < int(extra); i++ {
12063 {
12064 var maj byte
12065 var extra uint64
12066 var err error
12067 _ = maj
12068 _ = extra
12069 _ = err
12070
12071 {
12072
12073 b, err := cr.ReadByte()
12074 if err != nil {
12075 return err
12076 }
12077 if b != cbg.CborNull[0] {
12078 if err := cr.UnreadByte(); err != nil {
12079 return err
12080 }
12081 t.Rounds[i] = new(RepoPull_Round)
12082 if err := t.Rounds[i].UnmarshalCBOR(cr); err != nil {
12083 return xerrors.Errorf("unmarshaling t.Rounds[i] pointer: %w", err)
12084 }
12085 }
12086
12087 }
12088
12089 }
12090 }
12091 // t.Source (tangled.RepoPull_Source) (struct)
12092 case "source":
12093
12094 {
12095
12096 b, err := cr.ReadByte()
12097 if err != nil {
12098 return err
12099 }
12100 if b != cbg.CborNull[0] {
12101 if err := cr.UnreadByte(); err != nil {
12102 return err
12103 }
12104 t.Source = new(RepoPull_Source)
12105 if err := t.Source.UnmarshalCBOR(cr); err != nil {
12106 return xerrors.Errorf("unmarshaling t.Source pointer: %w", err)
12107 }
12108 }
12109
12110 }
12111 // t.Target (tangled.RepoPull_Target) (struct)
12112 case "target":
12113
12114 {
12115
12116 b, err := cr.ReadByte()
12117 if err != nil {
12118 return err
12119 }
12120 if b != cbg.CborNull[0] {
12121 if err := cr.UnreadByte(); err != nil {
12122 return err
12123 }
12124 t.Target = new(RepoPull_Target)
12125 if err := t.Target.UnmarshalCBOR(cr); err != nil {
12126 return xerrors.Errorf("unmarshaling t.Target pointer: %w", err)
12127 }
12128 }
12129
12130 }
12131 // t.Mentions ([]string) (slice)
12132 case "mentions":
12133
12134 maj, extra, err = cr.ReadHeader()
12135 if err != nil {
12136 return err
12137 }
12138
12139 if extra > 8192 {
12140 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
12141 }
12142
12143 if maj != cbg.MajArray {
12144 return fmt.Errorf("expected cbor array")
12145 }
12146
12147 if extra > 0 {
12148 t.Mentions = make([]string, extra)
12149 }
12150
12151 for i := 0; i < int(extra); i++ {
12152 {
12153 var maj byte
12154 var extra uint64
12155 var err error
12156 _ = maj
12157 _ = extra
12158 _ = err
12159
12160 {
12161 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12162 if err != nil {
12163 return err
12164 }
12165
12166 t.Mentions[i] = string(sval)
12167 }
12168
12169 }
12170 }
12171 // t.CreatedAt (string) (string)
12172 case "createdAt":
12173
12174 {
12175 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12176 if err != nil {
12177 return err
12178 }
12179
12180 t.CreatedAt = string(sval)
12181 }
12182 // t.References ([]string) (slice)
12183 case "references":
12184
12185 maj, extra, err = cr.ReadHeader()
12186 if err != nil {
12187 return err
12188 }
12189
12190 if extra > 8192 {
12191 return fmt.Errorf("t.References: array too large (%d)", extra)
12192 }
12193
12194 if maj != cbg.MajArray {
12195 return fmt.Errorf("expected cbor array")
12196 }
12197
12198 if extra > 0 {
12199 t.References = make([]string, extra)
12200 }
12201
12202 for i := 0; i < int(extra); i++ {
12203 {
12204 var maj byte
12205 var extra uint64
12206 var err error
12207 _ = maj
12208 _ = extra
12209 _ = err
12210
12211 {
12212 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12213 if err != nil {
12214 return err
12215 }
12216
12217 t.References[i] = string(sval)
12218 }
12219
12220 }
12221 }
12222 // t.DependentOn (string) (string)
12223 case "dependentOn":
12224
12225 {
12226 b, err := cr.ReadByte()
12227 if err != nil {
12228 return err
12229 }
12230 if b != cbg.CborNull[0] {
12231 if err := cr.UnreadByte(); err != nil {
12232 return err
12233 }
12234
12235 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12236 if err != nil {
12237 return err
12238 }
12239
12240 t.DependentOn = (*string)(&sval)
12241 }
12242 }
12243
12244 default:
12245 // Field doesn't exist on this type, so ignore it
12246 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
12247 return err
12248 }
12249 }
12250 }
12251
12252 return nil
12253}
12254func (t *RepoPullComment) MarshalCBOR(w io.Writer) error {
12255 if t == nil {
12256 _, err := w.Write(cbg.CborNull)
12257 return err
12258 }
12259
12260 cw := cbg.NewCborWriter(w)
12261 fieldCount := 6
12262
12263 if t.Mentions == nil {
12264 fieldCount--
12265 }
12266
12267 if t.References == nil {
12268 fieldCount--
12269 }
12270
12271 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
12272 return err
12273 }
12274
12275 // t.Body (string) (string)
12276 if len("body") > 1000000 {
12277 return xerrors.Errorf("Value in field \"body\" was too long")
12278 }
12279
12280 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
12281 return err
12282 }
12283 if _, err := cw.WriteString(string("body")); err != nil {
12284 return err
12285 }
12286
12287 if len(t.Body) > 1000000 {
12288 return xerrors.Errorf("Value in field t.Body was too long")
12289 }
12290
12291 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
12292 return err
12293 }
12294 if _, err := cw.WriteString(string(t.Body)); err != nil {
12295 return err
12296 }
12297
12298 // t.Pull (string) (string)
12299 if len("pull") > 1000000 {
12300 return xerrors.Errorf("Value in field \"pull\" was too long")
12301 }
12302
12303 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
12304 return err
12305 }
12306 if _, err := cw.WriteString(string("pull")); err != nil {
12307 return err
12308 }
12309
12310 if len(t.Pull) > 1000000 {
12311 return xerrors.Errorf("Value in field t.Pull was too long")
12312 }
12313
12314 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
12315 return err
12316 }
12317 if _, err := cw.WriteString(string(t.Pull)); err != nil {
12318 return err
12319 }
12320
12321 // t.LexiconTypeID (string) (string)
12322 if len("$type") > 1000000 {
12323 return xerrors.Errorf("Value in field \"$type\" was too long")
12324 }
12325
12326 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
12327 return err
12328 }
12329 if _, err := cw.WriteString(string("$type")); err != nil {
12330 return err
12331 }
12332
12333 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.comment"))); err != nil {
12334 return err
12335 }
12336 if _, err := cw.WriteString(string("sh.tangled.repo.pull.comment")); err != nil {
12337 return err
12338 }
12339
12340 // t.Mentions ([]string) (slice)
12341 if t.Mentions != nil {
12342
12343 if len("mentions") > 1000000 {
12344 return xerrors.Errorf("Value in field \"mentions\" was too long")
12345 }
12346
12347 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
12348 return err
12349 }
12350 if _, err := cw.WriteString(string("mentions")); err != nil {
12351 return err
12352 }
12353
12354 if len(t.Mentions) > 8192 {
12355 return xerrors.Errorf("Slice value in field t.Mentions was too long")
12356 }
12357
12358 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
12359 return err
12360 }
12361 for _, v := range t.Mentions {
12362 if len(v) > 1000000 {
12363 return xerrors.Errorf("Value in field v was too long")
12364 }
12365
12366 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
12367 return err
12368 }
12369 if _, err := cw.WriteString(string(v)); err != nil {
12370 return err
12371 }
12372
12373 }
12374 }
12375
12376 // t.CreatedAt (string) (string)
12377 if len("createdAt") > 1000000 {
12378 return xerrors.Errorf("Value in field \"createdAt\" was too long")
12379 }
12380
12381 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
12382 return err
12383 }
12384 if _, err := cw.WriteString(string("createdAt")); err != nil {
12385 return err
12386 }
12387
12388 if len(t.CreatedAt) > 1000000 {
12389 return xerrors.Errorf("Value in field t.CreatedAt was too long")
12390 }
12391
12392 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
12393 return err
12394 }
12395 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
12396 return err
12397 }
12398
12399 // t.References ([]string) (slice)
12400 if t.References != nil {
12401
12402 if len("references") > 1000000 {
12403 return xerrors.Errorf("Value in field \"references\" was too long")
12404 }
12405
12406 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
12407 return err
12408 }
12409 if _, err := cw.WriteString(string("references")); err != nil {
12410 return err
12411 }
12412
12413 if len(t.References) > 8192 {
12414 return xerrors.Errorf("Slice value in field t.References was too long")
12415 }
12416
12417 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
12418 return err
12419 }
12420 for _, v := range t.References {
12421 if len(v) > 1000000 {
12422 return xerrors.Errorf("Value in field v was too long")
12423 }
12424
12425 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
12426 return err
12427 }
12428 if _, err := cw.WriteString(string(v)); err != nil {
12429 return err
12430 }
12431
12432 }
12433 }
12434 return nil
12435}
12436
12437func (t *RepoPullComment) UnmarshalCBOR(r io.Reader) (err error) {
12438 *t = RepoPullComment{}
12439
12440 cr := cbg.NewCborReader(r)
12441
12442 maj, extra, err := cr.ReadHeader()
12443 if err != nil {
12444 return err
12445 }
12446 defer func() {
12447 if err == io.EOF {
12448 err = io.ErrUnexpectedEOF
12449 }
12450 }()
12451
12452 if maj != cbg.MajMap {
12453 return fmt.Errorf("cbor input should be of type map")
12454 }
12455
12456 if extra > cbg.MaxLength {
12457 return fmt.Errorf("RepoPullComment: map struct too large (%d)", extra)
12458 }
12459
12460 n := extra
12461
12462 nameBuf := make([]byte, 10)
12463 for i := uint64(0); i < n; i++ {
12464 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
12465 if err != nil {
12466 return err
12467 }
12468
12469 if !ok {
12470 // Field doesn't exist on this type, so ignore it
12471 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
12472 return err
12473 }
12474 continue
12475 }
12476
12477 switch string(nameBuf[:nameLen]) {
12478 // t.Body (string) (string)
12479 case "body":
12480
12481 {
12482 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12483 if err != nil {
12484 return err
12485 }
12486
12487 t.Body = string(sval)
12488 }
12489 // t.Pull (string) (string)
12490 case "pull":
12491
12492 {
12493 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12494 if err != nil {
12495 return err
12496 }
12497
12498 t.Pull = string(sval)
12499 }
12500 // t.LexiconTypeID (string) (string)
12501 case "$type":
12502
12503 {
12504 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12505 if err != nil {
12506 return err
12507 }
12508
12509 t.LexiconTypeID = string(sval)
12510 }
12511 // t.Mentions ([]string) (slice)
12512 case "mentions":
12513
12514 maj, extra, err = cr.ReadHeader()
12515 if err != nil {
12516 return err
12517 }
12518
12519 if extra > 8192 {
12520 return fmt.Errorf("t.Mentions: array too large (%d)", extra)
12521 }
12522
12523 if maj != cbg.MajArray {
12524 return fmt.Errorf("expected cbor array")
12525 }
12526
12527 if extra > 0 {
12528 t.Mentions = make([]string, extra)
12529 }
12530
12531 for i := 0; i < int(extra); i++ {
12532 {
12533 var maj byte
12534 var extra uint64
12535 var err error
12536 _ = maj
12537 _ = extra
12538 _ = err
12539
12540 {
12541 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12542 if err != nil {
12543 return err
12544 }
12545
12546 t.Mentions[i] = string(sval)
12547 }
12548
12549 }
12550 }
12551 // t.CreatedAt (string) (string)
12552 case "createdAt":
12553
12554 {
12555 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12556 if err != nil {
12557 return err
12558 }
12559
12560 t.CreatedAt = string(sval)
12561 }
12562 // t.References ([]string) (slice)
12563 case "references":
12564
12565 maj, extra, err = cr.ReadHeader()
12566 if err != nil {
12567 return err
12568 }
12569
12570 if extra > 8192 {
12571 return fmt.Errorf("t.References: array too large (%d)", extra)
12572 }
12573
12574 if maj != cbg.MajArray {
12575 return fmt.Errorf("expected cbor array")
12576 }
12577
12578 if extra > 0 {
12579 t.References = make([]string, extra)
12580 }
12581
12582 for i := 0; i < int(extra); i++ {
12583 {
12584 var maj byte
12585 var extra uint64
12586 var err error
12587 _ = maj
12588 _ = extra
12589 _ = err
12590
12591 {
12592 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12593 if err != nil {
12594 return err
12595 }
12596
12597 t.References[i] = string(sval)
12598 }
12599
12600 }
12601 }
12602
12603 default:
12604 // Field doesn't exist on this type, so ignore it
12605 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
12606 return err
12607 }
12608 }
12609 }
12610
12611 return nil
12612}
12613func (t *RepoPull_Round) MarshalCBOR(w io.Writer) error {
12614 if t == nil {
12615 _, err := w.Write(cbg.CborNull)
12616 return err
12617 }
12618
12619 cw := cbg.NewCborWriter(w)
12620
12621 if _, err := cw.Write([]byte{162}); err != nil {
12622 return err
12623 }
12624
12625 // t.CreatedAt (string) (string)
12626 if len("createdAt") > 1000000 {
12627 return xerrors.Errorf("Value in field \"createdAt\" was too long")
12628 }
12629
12630 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
12631 return err
12632 }
12633 if _, err := cw.WriteString(string("createdAt")); err != nil {
12634 return err
12635 }
12636
12637 if len(t.CreatedAt) > 1000000 {
12638 return xerrors.Errorf("Value in field t.CreatedAt was too long")
12639 }
12640
12641 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
12642 return err
12643 }
12644 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
12645 return err
12646 }
12647
12648 // t.PatchBlob (util.LexBlob) (struct)
12649 if len("patchBlob") > 1000000 {
12650 return xerrors.Errorf("Value in field \"patchBlob\" was too long")
12651 }
12652
12653 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patchBlob"))); err != nil {
12654 return err
12655 }
12656 if _, err := cw.WriteString(string("patchBlob")); err != nil {
12657 return err
12658 }
12659
12660 if err := t.PatchBlob.MarshalCBOR(cw); err != nil {
12661 return err
12662 }
12663 return nil
12664}
12665
12666func (t *RepoPull_Round) UnmarshalCBOR(r io.Reader) (err error) {
12667 *t = RepoPull_Round{}
12668
12669 cr := cbg.NewCborReader(r)
12670
12671 maj, extra, err := cr.ReadHeader()
12672 if err != nil {
12673 return err
12674 }
12675 defer func() {
12676 if err == io.EOF {
12677 err = io.ErrUnexpectedEOF
12678 }
12679 }()
12680
12681 if maj != cbg.MajMap {
12682 return fmt.Errorf("cbor input should be of type map")
12683 }
12684
12685 if extra > cbg.MaxLength {
12686 return fmt.Errorf("RepoPull_Round: map struct too large (%d)", extra)
12687 }
12688
12689 n := extra
12690
12691 nameBuf := make([]byte, 9)
12692 for i := uint64(0); i < n; i++ {
12693 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
12694 if err != nil {
12695 return err
12696 }
12697
12698 if !ok {
12699 // Field doesn't exist on this type, so ignore it
12700 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
12701 return err
12702 }
12703 continue
12704 }
12705
12706 switch string(nameBuf[:nameLen]) {
12707 // t.CreatedAt (string) (string)
12708 case "createdAt":
12709
12710 {
12711 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12712 if err != nil {
12713 return err
12714 }
12715
12716 t.CreatedAt = string(sval)
12717 }
12718 // t.PatchBlob (util.LexBlob) (struct)
12719 case "patchBlob":
12720
12721 {
12722
12723 b, err := cr.ReadByte()
12724 if err != nil {
12725 return err
12726 }
12727 if b != cbg.CborNull[0] {
12728 if err := cr.UnreadByte(); err != nil {
12729 return err
12730 }
12731 t.PatchBlob = new(util.LexBlob)
12732 if err := t.PatchBlob.UnmarshalCBOR(cr); err != nil {
12733 return xerrors.Errorf("unmarshaling t.PatchBlob pointer: %w", err)
12734 }
12735 }
12736
12737 }
12738
12739 default:
12740 // Field doesn't exist on this type, so ignore it
12741 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
12742 return err
12743 }
12744 }
12745 }
12746
12747 return nil
12748}
12749func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error {
12750 if t == nil {
12751 _, err := w.Write(cbg.CborNull)
12752 return err
12753 }
12754
12755 cw := cbg.NewCborWriter(w)
12756 fieldCount := 2
12757
12758 if t.Repo == nil {
12759 fieldCount--
12760 }
12761
12762 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
12763 return err
12764 }
12765
12766 // t.Repo (string) (string)
12767 if t.Repo != nil {
12768
12769 if len("repo") > 1000000 {
12770 return xerrors.Errorf("Value in field \"repo\" was too long")
12771 }
12772
12773 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
12774 return err
12775 }
12776 if _, err := cw.WriteString(string("repo")); err != nil {
12777 return err
12778 }
12779
12780 if t.Repo == nil {
12781 if _, err := cw.Write(cbg.CborNull); err != nil {
12782 return err
12783 }
12784 } else {
12785 if len(*t.Repo) > 1000000 {
12786 return xerrors.Errorf("Value in field t.Repo was too long")
12787 }
12788
12789 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
12790 return err
12791 }
12792 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
12793 return err
12794 }
12795 }
12796 }
12797
12798 // t.Branch (string) (string)
12799 if len("branch") > 1000000 {
12800 return xerrors.Errorf("Value in field \"branch\" was too long")
12801 }
12802
12803 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
12804 return err
12805 }
12806 if _, err := cw.WriteString(string("branch")); err != nil {
12807 return err
12808 }
12809
12810 if len(t.Branch) > 1000000 {
12811 return xerrors.Errorf("Value in field t.Branch was too long")
12812 }
12813
12814 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
12815 return err
12816 }
12817 if _, err := cw.WriteString(string(t.Branch)); err != nil {
12818 return err
12819 }
12820 return nil
12821}
12822
12823func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) {
12824 *t = RepoPull_Source{}
12825
12826 cr := cbg.NewCborReader(r)
12827
12828 maj, extra, err := cr.ReadHeader()
12829 if err != nil {
12830 return err
12831 }
12832 defer func() {
12833 if err == io.EOF {
12834 err = io.ErrUnexpectedEOF
12835 }
12836 }()
12837
12838 if maj != cbg.MajMap {
12839 return fmt.Errorf("cbor input should be of type map")
12840 }
12841
12842 if extra > cbg.MaxLength {
12843 return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra)
12844 }
12845
12846 n := extra
12847
12848 nameBuf := make([]byte, 6)
12849 for i := uint64(0); i < n; i++ {
12850 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
12851 if err != nil {
12852 return err
12853 }
12854
12855 if !ok {
12856 // Field doesn't exist on this type, so ignore it
12857 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
12858 return err
12859 }
12860 continue
12861 }
12862
12863 switch string(nameBuf[:nameLen]) {
12864 // t.Repo (string) (string)
12865 case "repo":
12866
12867 {
12868 b, err := cr.ReadByte()
12869 if err != nil {
12870 return err
12871 }
12872 if b != cbg.CborNull[0] {
12873 if err := cr.UnreadByte(); err != nil {
12874 return err
12875 }
12876
12877 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12878 if err != nil {
12879 return err
12880 }
12881
12882 t.Repo = (*string)(&sval)
12883 }
12884 }
12885 // t.Branch (string) (string)
12886 case "branch":
12887
12888 {
12889 sval, err := cbg.ReadStringWithMax(cr, 1000000)
12890 if err != nil {
12891 return err
12892 }
12893
12894 t.Branch = string(sval)
12895 }
12896
12897 default:
12898 // Field doesn't exist on this type, so ignore it
12899 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
12900 return err
12901 }
12902 }
12903 }
12904
12905 return nil
12906}
12907func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error {
12908 if t == nil {
12909 _, err := w.Write(cbg.CborNull)
12910 return err
12911 }
12912
12913 cw := cbg.NewCborWriter(w)
12914
12915 if _, err := cw.Write([]byte{163}); err != nil {
12916 return err
12917 }
12918
12919 // t.Pull (string) (string)
12920 if len("pull") > 1000000 {
12921 return xerrors.Errorf("Value in field \"pull\" was too long")
12922 }
12923
12924 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
12925 return err
12926 }
12927 if _, err := cw.WriteString(string("pull")); err != nil {
12928 return err
12929 }
12930
12931 if len(t.Pull) > 1000000 {
12932 return xerrors.Errorf("Value in field t.Pull was too long")
12933 }
12934
12935 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
12936 return err
12937 }
12938 if _, err := cw.WriteString(string(t.Pull)); err != nil {
12939 return err
12940 }
12941
12942 // t.LexiconTypeID (string) (string)
12943 if len("$type") > 1000000 {
12944 return xerrors.Errorf("Value in field \"$type\" was too long")
12945 }
12946
12947 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
12948 return err
12949 }
12950 if _, err := cw.WriteString(string("$type")); err != nil {
12951 return err
12952 }
12953
12954 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil {
12955 return err
12956 }
12957 if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil {
12958 return err
12959 }
12960
12961 // t.Status (string) (string)
12962 if len("status") > 1000000 {
12963 return xerrors.Errorf("Value in field \"status\" was too long")
12964 }
12965
12966 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
12967 return err
12968 }
12969 if _, err := cw.WriteString(string("status")); err != nil {
12970 return err
12971 }
12972
12973 if len(t.Status) > 1000000 {
12974 return xerrors.Errorf("Value in field t.Status was too long")
12975 }
12976
12977 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
12978 return err
12979 }
12980 if _, err := cw.WriteString(string(t.Status)); err != nil {
12981 return err
12982 }
12983 return nil
12984}
12985
12986func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) {
12987 *t = RepoPullStatus{}
12988
12989 cr := cbg.NewCborReader(r)
12990
12991 maj, extra, err := cr.ReadHeader()
12992 if err != nil {
12993 return err
12994 }
12995 defer func() {
12996 if err == io.EOF {
12997 err = io.ErrUnexpectedEOF
12998 }
12999 }()
13000
13001 if maj != cbg.MajMap {
13002 return fmt.Errorf("cbor input should be of type map")
13003 }
13004
13005 if extra > cbg.MaxLength {
13006 return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra)
13007 }
13008
13009 n := extra
13010
13011 nameBuf := make([]byte, 6)
13012 for i := uint64(0); i < n; i++ {
13013 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
13014 if err != nil {
13015 return err
13016 }
13017
13018 if !ok {
13019 // Field doesn't exist on this type, so ignore it
13020 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
13021 return err
13022 }
13023 continue
13024 }
13025
13026 switch string(nameBuf[:nameLen]) {
13027 // t.Pull (string) (string)
13028 case "pull":
13029
13030 {
13031 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13032 if err != nil {
13033 return err
13034 }
13035
13036 t.Pull = string(sval)
13037 }
13038 // t.LexiconTypeID (string) (string)
13039 case "$type":
13040
13041 {
13042 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13043 if err != nil {
13044 return err
13045 }
13046
13047 t.LexiconTypeID = string(sval)
13048 }
13049 // t.Status (string) (string)
13050 case "status":
13051
13052 {
13053 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13054 if err != nil {
13055 return err
13056 }
13057
13058 t.Status = string(sval)
13059 }
13060
13061 default:
13062 // Field doesn't exist on this type, so ignore it
13063 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
13064 return err
13065 }
13066 }
13067 }
13068
13069 return nil
13070}
13071func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error {
13072 if t == nil {
13073 _, err := w.Write(cbg.CborNull)
13074 return err
13075 }
13076
13077 cw := cbg.NewCborWriter(w)
13078
13079 if _, err := cw.Write([]byte{162}); err != nil {
13080 return err
13081 }
13082
13083 // t.Repo (string) (string)
13084 if len("repo") > 1000000 {
13085 return xerrors.Errorf("Value in field \"repo\" was too long")
13086 }
13087
13088 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
13089 return err
13090 }
13091 if _, err := cw.WriteString(string("repo")); err != nil {
13092 return err
13093 }
13094
13095 if len(t.Repo) > 1000000 {
13096 return xerrors.Errorf("Value in field t.Repo was too long")
13097 }
13098
13099 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
13100 return err
13101 }
13102 if _, err := cw.WriteString(string(t.Repo)); err != nil {
13103 return err
13104 }
13105
13106 // t.Branch (string) (string)
13107 if len("branch") > 1000000 {
13108 return xerrors.Errorf("Value in field \"branch\" was too long")
13109 }
13110
13111 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
13112 return err
13113 }
13114 if _, err := cw.WriteString(string("branch")); err != nil {
13115 return err
13116 }
13117
13118 if len(t.Branch) > 1000000 {
13119 return xerrors.Errorf("Value in field t.Branch was too long")
13120 }
13121
13122 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
13123 return err
13124 }
13125 if _, err := cw.WriteString(string(t.Branch)); err != nil {
13126 return err
13127 }
13128 return nil
13129}
13130
13131func (t *RepoPull_Target) UnmarshalCBOR(r io.Reader) (err error) {
13132 *t = RepoPull_Target{}
13133
13134 cr := cbg.NewCborReader(r)
13135
13136 maj, extra, err := cr.ReadHeader()
13137 if err != nil {
13138 return err
13139 }
13140 defer func() {
13141 if err == io.EOF {
13142 err = io.ErrUnexpectedEOF
13143 }
13144 }()
13145
13146 if maj != cbg.MajMap {
13147 return fmt.Errorf("cbor input should be of type map")
13148 }
13149
13150 if extra > cbg.MaxLength {
13151 return fmt.Errorf("RepoPull_Target: map struct too large (%d)", extra)
13152 }
13153
13154 n := extra
13155
13156 nameBuf := make([]byte, 6)
13157 for i := uint64(0); i < n; i++ {
13158 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
13159 if err != nil {
13160 return err
13161 }
13162
13163 if !ok {
13164 // Field doesn't exist on this type, so ignore it
13165 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
13166 return err
13167 }
13168 continue
13169 }
13170
13171 switch string(nameBuf[:nameLen]) {
13172 // t.Repo (string) (string)
13173 case "repo":
13174
13175 {
13176 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13177 if err != nil {
13178 return err
13179 }
13180
13181 t.Repo = string(sval)
13182 }
13183 // t.Branch (string) (string)
13184 case "branch":
13185
13186 {
13187 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13188 if err != nil {
13189 return err
13190 }
13191
13192 t.Branch = string(sval)
13193 }
13194
13195 default:
13196 // Field doesn't exist on this type, so ignore it
13197 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
13198 return err
13199 }
13200 }
13201 }
13202
13203 return nil
13204}
13205func (t *Spindle) MarshalCBOR(w io.Writer) error {
13206 if t == nil {
13207 _, err := w.Write(cbg.CborNull)
13208 return err
13209 }
13210
13211 cw := cbg.NewCborWriter(w)
13212
13213 if _, err := cw.Write([]byte{162}); err != nil {
13214 return err
13215 }
13216
13217 // t.LexiconTypeID (string) (string)
13218 if len("$type") > 1000000 {
13219 return xerrors.Errorf("Value in field \"$type\" was too long")
13220 }
13221
13222 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
13223 return err
13224 }
13225 if _, err := cw.WriteString(string("$type")); err != nil {
13226 return err
13227 }
13228
13229 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle"))); err != nil {
13230 return err
13231 }
13232 if _, err := cw.WriteString(string("sh.tangled.spindle")); err != nil {
13233 return err
13234 }
13235
13236 // t.CreatedAt (string) (string)
13237 if len("createdAt") > 1000000 {
13238 return xerrors.Errorf("Value in field \"createdAt\" was too long")
13239 }
13240
13241 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
13242 return err
13243 }
13244 if _, err := cw.WriteString(string("createdAt")); err != nil {
13245 return err
13246 }
13247
13248 if len(t.CreatedAt) > 1000000 {
13249 return xerrors.Errorf("Value in field t.CreatedAt was too long")
13250 }
13251
13252 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
13253 return err
13254 }
13255 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
13256 return err
13257 }
13258 return nil
13259}
13260
13261func (t *Spindle) UnmarshalCBOR(r io.Reader) (err error) {
13262 *t = Spindle{}
13263
13264 cr := cbg.NewCborReader(r)
13265
13266 maj, extra, err := cr.ReadHeader()
13267 if err != nil {
13268 return err
13269 }
13270 defer func() {
13271 if err == io.EOF {
13272 err = io.ErrUnexpectedEOF
13273 }
13274 }()
13275
13276 if maj != cbg.MajMap {
13277 return fmt.Errorf("cbor input should be of type map")
13278 }
13279
13280 if extra > cbg.MaxLength {
13281 return fmt.Errorf("Spindle: map struct too large (%d)", extra)
13282 }
13283
13284 n := extra
13285
13286 nameBuf := make([]byte, 9)
13287 for i := uint64(0); i < n; i++ {
13288 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
13289 if err != nil {
13290 return err
13291 }
13292
13293 if !ok {
13294 // Field doesn't exist on this type, so ignore it
13295 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
13296 return err
13297 }
13298 continue
13299 }
13300
13301 switch string(nameBuf[:nameLen]) {
13302 // t.LexiconTypeID (string) (string)
13303 case "$type":
13304
13305 {
13306 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13307 if err != nil {
13308 return err
13309 }
13310
13311 t.LexiconTypeID = string(sval)
13312 }
13313 // t.CreatedAt (string) (string)
13314 case "createdAt":
13315
13316 {
13317 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13318 if err != nil {
13319 return err
13320 }
13321
13322 t.CreatedAt = string(sval)
13323 }
13324
13325 default:
13326 // Field doesn't exist on this type, so ignore it
13327 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
13328 return err
13329 }
13330 }
13331 }
13332
13333 return nil
13334}
13335func (t *SpindleMember) MarshalCBOR(w io.Writer) error {
13336 if t == nil {
13337 _, err := w.Write(cbg.CborNull)
13338 return err
13339 }
13340
13341 cw := cbg.NewCborWriter(w)
13342
13343 if _, err := cw.Write([]byte{164}); err != nil {
13344 return err
13345 }
13346
13347 // t.LexiconTypeID (string) (string)
13348 if len("$type") > 1000000 {
13349 return xerrors.Errorf("Value in field \"$type\" was too long")
13350 }
13351
13352 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
13353 return err
13354 }
13355 if _, err := cw.WriteString(string("$type")); err != nil {
13356 return err
13357 }
13358
13359 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle.member"))); err != nil {
13360 return err
13361 }
13362 if _, err := cw.WriteString(string("sh.tangled.spindle.member")); err != nil {
13363 return err
13364 }
13365
13366 // t.Subject (string) (string)
13367 if len("subject") > 1000000 {
13368 return xerrors.Errorf("Value in field \"subject\" was too long")
13369 }
13370
13371 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
13372 return err
13373 }
13374 if _, err := cw.WriteString(string("subject")); err != nil {
13375 return err
13376 }
13377
13378 if len(t.Subject) > 1000000 {
13379 return xerrors.Errorf("Value in field t.Subject was too long")
13380 }
13381
13382 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
13383 return err
13384 }
13385 if _, err := cw.WriteString(string(t.Subject)); err != nil {
13386 return err
13387 }
13388
13389 // t.Instance (string) (string)
13390 if len("instance") > 1000000 {
13391 return xerrors.Errorf("Value in field \"instance\" was too long")
13392 }
13393
13394 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("instance"))); err != nil {
13395 return err
13396 }
13397 if _, err := cw.WriteString(string("instance")); err != nil {
13398 return err
13399 }
13400
13401 if len(t.Instance) > 1000000 {
13402 return xerrors.Errorf("Value in field t.Instance was too long")
13403 }
13404
13405 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Instance))); err != nil {
13406 return err
13407 }
13408 if _, err := cw.WriteString(string(t.Instance)); err != nil {
13409 return err
13410 }
13411
13412 // t.CreatedAt (string) (string)
13413 if len("createdAt") > 1000000 {
13414 return xerrors.Errorf("Value in field \"createdAt\" was too long")
13415 }
13416
13417 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
13418 return err
13419 }
13420 if _, err := cw.WriteString(string("createdAt")); err != nil {
13421 return err
13422 }
13423
13424 if len(t.CreatedAt) > 1000000 {
13425 return xerrors.Errorf("Value in field t.CreatedAt was too long")
13426 }
13427
13428 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
13429 return err
13430 }
13431 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
13432 return err
13433 }
13434 return nil
13435}
13436
13437func (t *SpindleMember) UnmarshalCBOR(r io.Reader) (err error) {
13438 *t = SpindleMember{}
13439
13440 cr := cbg.NewCborReader(r)
13441
13442 maj, extra, err := cr.ReadHeader()
13443 if err != nil {
13444 return err
13445 }
13446 defer func() {
13447 if err == io.EOF {
13448 err = io.ErrUnexpectedEOF
13449 }
13450 }()
13451
13452 if maj != cbg.MajMap {
13453 return fmt.Errorf("cbor input should be of type map")
13454 }
13455
13456 if extra > cbg.MaxLength {
13457 return fmt.Errorf("SpindleMember: map struct too large (%d)", extra)
13458 }
13459
13460 n := extra
13461
13462 nameBuf := make([]byte, 9)
13463 for i := uint64(0); i < n; i++ {
13464 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
13465 if err != nil {
13466 return err
13467 }
13468
13469 if !ok {
13470 // Field doesn't exist on this type, so ignore it
13471 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
13472 return err
13473 }
13474 continue
13475 }
13476
13477 switch string(nameBuf[:nameLen]) {
13478 // t.LexiconTypeID (string) (string)
13479 case "$type":
13480
13481 {
13482 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13483 if err != nil {
13484 return err
13485 }
13486
13487 t.LexiconTypeID = string(sval)
13488 }
13489 // t.Subject (string) (string)
13490 case "subject":
13491
13492 {
13493 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13494 if err != nil {
13495 return err
13496 }
13497
13498 t.Subject = string(sval)
13499 }
13500 // t.Instance (string) (string)
13501 case "instance":
13502
13503 {
13504 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13505 if err != nil {
13506 return err
13507 }
13508
13509 t.Instance = string(sval)
13510 }
13511 // t.CreatedAt (string) (string)
13512 case "createdAt":
13513
13514 {
13515 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13516 if err != nil {
13517 return err
13518 }
13519
13520 t.CreatedAt = string(sval)
13521 }
13522
13523 default:
13524 // Field doesn't exist on this type, so ignore it
13525 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
13526 return err
13527 }
13528 }
13529 }
13530
13531 return nil
13532}
13533func (t *String) MarshalCBOR(w io.Writer) error {
13534 if t == nil {
13535 _, err := w.Write(cbg.CborNull)
13536 return err
13537 }
13538
13539 cw := cbg.NewCborWriter(w)
13540
13541 if _, err := cw.Write([]byte{165}); err != nil {
13542 return err
13543 }
13544
13545 // t.LexiconTypeID (string) (string)
13546 if len("$type") > 1000000 {
13547 return xerrors.Errorf("Value in field \"$type\" was too long")
13548 }
13549
13550 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
13551 return err
13552 }
13553 if _, err := cw.WriteString(string("$type")); err != nil {
13554 return err
13555 }
13556
13557 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.string"))); err != nil {
13558 return err
13559 }
13560 if _, err := cw.WriteString(string("sh.tangled.string")); err != nil {
13561 return err
13562 }
13563
13564 // t.Contents (string) (string)
13565 if len("contents") > 1000000 {
13566 return xerrors.Errorf("Value in field \"contents\" was too long")
13567 }
13568
13569 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("contents"))); err != nil {
13570 return err
13571 }
13572 if _, err := cw.WriteString(string("contents")); err != nil {
13573 return err
13574 }
13575
13576 if len(t.Contents) > 1000000 {
13577 return xerrors.Errorf("Value in field t.Contents was too long")
13578 }
13579
13580 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Contents))); err != nil {
13581 return err
13582 }
13583 if _, err := cw.WriteString(string(t.Contents)); err != nil {
13584 return err
13585 }
13586
13587 // t.Filename (string) (string)
13588 if len("filename") > 1000000 {
13589 return xerrors.Errorf("Value in field \"filename\" was too long")
13590 }
13591
13592 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("filename"))); err != nil {
13593 return err
13594 }
13595 if _, err := cw.WriteString(string("filename")); err != nil {
13596 return err
13597 }
13598
13599 if len(t.Filename) > 1000000 {
13600 return xerrors.Errorf("Value in field t.Filename was too long")
13601 }
13602
13603 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Filename))); err != nil {
13604 return err
13605 }
13606 if _, err := cw.WriteString(string(t.Filename)); err != nil {
13607 return err
13608 }
13609
13610 // t.CreatedAt (string) (string)
13611 if len("createdAt") > 1000000 {
13612 return xerrors.Errorf("Value in field \"createdAt\" was too long")
13613 }
13614
13615 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
13616 return err
13617 }
13618 if _, err := cw.WriteString(string("createdAt")); err != nil {
13619 return err
13620 }
13621
13622 if len(t.CreatedAt) > 1000000 {
13623 return xerrors.Errorf("Value in field t.CreatedAt was too long")
13624 }
13625
13626 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
13627 return err
13628 }
13629 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
13630 return err
13631 }
13632
13633 // t.Description (string) (string)
13634 if len("description") > 1000000 {
13635 return xerrors.Errorf("Value in field \"description\" was too long")
13636 }
13637
13638 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
13639 return err
13640 }
13641 if _, err := cw.WriteString(string("description")); err != nil {
13642 return err
13643 }
13644
13645 if len(t.Description) > 1000000 {
13646 return xerrors.Errorf("Value in field t.Description was too long")
13647 }
13648
13649 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil {
13650 return err
13651 }
13652 if _, err := cw.WriteString(string(t.Description)); err != nil {
13653 return err
13654 }
13655 return nil
13656}
13657
13658func (t *String) UnmarshalCBOR(r io.Reader) (err error) {
13659 *t = String{}
13660
13661 cr := cbg.NewCborReader(r)
13662
13663 maj, extra, err := cr.ReadHeader()
13664 if err != nil {
13665 return err
13666 }
13667 defer func() {
13668 if err == io.EOF {
13669 err = io.ErrUnexpectedEOF
13670 }
13671 }()
13672
13673 if maj != cbg.MajMap {
13674 return fmt.Errorf("cbor input should be of type map")
13675 }
13676
13677 if extra > cbg.MaxLength {
13678 return fmt.Errorf("String: map struct too large (%d)", extra)
13679 }
13680
13681 n := extra
13682
13683 nameBuf := make([]byte, 11)
13684 for i := uint64(0); i < n; i++ {
13685 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
13686 if err != nil {
13687 return err
13688 }
13689
13690 if !ok {
13691 // Field doesn't exist on this type, so ignore it
13692 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
13693 return err
13694 }
13695 continue
13696 }
13697
13698 switch string(nameBuf[:nameLen]) {
13699 // t.LexiconTypeID (string) (string)
13700 case "$type":
13701
13702 {
13703 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13704 if err != nil {
13705 return err
13706 }
13707
13708 t.LexiconTypeID = string(sval)
13709 }
13710 // t.Contents (string) (string)
13711 case "contents":
13712
13713 {
13714 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13715 if err != nil {
13716 return err
13717 }
13718
13719 t.Contents = string(sval)
13720 }
13721 // t.Filename (string) (string)
13722 case "filename":
13723
13724 {
13725 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13726 if err != nil {
13727 return err
13728 }
13729
13730 t.Filename = string(sval)
13731 }
13732 // t.CreatedAt (string) (string)
13733 case "createdAt":
13734
13735 {
13736 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13737 if err != nil {
13738 return err
13739 }
13740
13741 t.CreatedAt = string(sval)
13742 }
13743 // t.Description (string) (string)
13744 case "description":
13745
13746 {
13747 sval, err := cbg.ReadStringWithMax(cr, 1000000)
13748 if err != nil {
13749 return err
13750 }
13751
13752 t.Description = string(sval)
13753 }
13754
13755 default:
13756 // Field doesn't exist on this type, so ignore it
13757 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
13758 return err
13759 }
13760 }
13761 }
13762
13763 return nil
13764}