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