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