julien.rbrt.fr
forked from
tangled.org/core
Monorepo for Tangled — https://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 util "github.com/bluesky-social/indigo/lex/util"
12 cid "github.com/ipfs/go-cid"
13 cbg "github.com/whyrusleeping/cbor-gen"
14 xerrors "golang.org/x/xerrors"
15)
16
17var _ = xerrors.Errorf
18var _ = cid.Undef
19var _ = math.E
20var _ = sort.Sort
21
22func (t *ActorProfile) MarshalCBOR(w io.Writer) error {
23 if t == nil {
24 _, err := w.Write(cbg.CborNull)
25 return err
26 }
27
28 cw := cbg.NewCborWriter(w)
29 fieldCount := 7
30
31 if t.Description == nil {
32 fieldCount--
33 }
34
35 if t.Links == nil {
36 fieldCount--
37 }
38
39 if t.Location == nil {
40 fieldCount--
41 }
42
43 if t.PinnedRepositories == nil {
44 fieldCount--
45 }
46
47 if t.Stats == nil {
48 fieldCount--
49 }
50
51 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
52 return err
53 }
54
55 // t.LexiconTypeID (string) (string)
56 if len("$type") > 1000000 {
57 return xerrors.Errorf("Value in field \"$type\" was too long")
58 }
59
60 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
61 return err
62 }
63 if _, err := cw.WriteString(string("$type")); err != nil {
64 return err
65 }
66
67 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.actor.profile"))); err != nil {
68 return err
69 }
70 if _, err := cw.WriteString(string("sh.tangled.actor.profile")); err != nil {
71 return err
72 }
73
74 // t.Links ([]string) (slice)
75 if t.Links != nil {
76
77 if len("links") > 1000000 {
78 return xerrors.Errorf("Value in field \"links\" was too long")
79 }
80
81 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("links"))); err != nil {
82 return err
83 }
84 if _, err := cw.WriteString(string("links")); err != nil {
85 return err
86 }
87
88 if len(t.Links) > 8192 {
89 return xerrors.Errorf("Slice value in field t.Links was too long")
90 }
91
92 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Links))); err != nil {
93 return err
94 }
95 for _, v := range t.Links {
96 if len(v) > 1000000 {
97 return xerrors.Errorf("Value in field v was too long")
98 }
99
100 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
101 return err
102 }
103 if _, err := cw.WriteString(string(v)); err != nil {
104 return err
105 }
106
107 }
108 }
109
110 // t.Stats ([]string) (slice)
111 if t.Stats != nil {
112
113 if len("stats") > 1000000 {
114 return xerrors.Errorf("Value in field \"stats\" was too long")
115 }
116
117 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("stats"))); err != nil {
118 return err
119 }
120 if _, err := cw.WriteString(string("stats")); err != nil {
121 return err
122 }
123
124 if len(t.Stats) > 8192 {
125 return xerrors.Errorf("Slice value in field t.Stats was too long")
126 }
127
128 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Stats))); err != nil {
129 return err
130 }
131 for _, v := range t.Stats {
132 if len(v) > 1000000 {
133 return xerrors.Errorf("Value in field v was too long")
134 }
135
136 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
137 return err
138 }
139 if _, err := cw.WriteString(string(v)); err != nil {
140 return err
141 }
142
143 }
144 }
145
146 // t.Bluesky (bool) (bool)
147 if len("bluesky") > 1000000 {
148 return xerrors.Errorf("Value in field \"bluesky\" was too long")
149 }
150
151 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("bluesky"))); err != nil {
152 return err
153 }
154 if _, err := cw.WriteString(string("bluesky")); err != nil {
155 return err
156 }
157
158 if err := cbg.WriteBool(w, t.Bluesky); err != nil {
159 return err
160 }
161
162 // t.Location (string) (string)
163 if t.Location != nil {
164
165 if len("location") > 1000000 {
166 return xerrors.Errorf("Value in field \"location\" was too long")
167 }
168
169 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("location"))); err != nil {
170 return err
171 }
172 if _, err := cw.WriteString(string("location")); err != nil {
173 return err
174 }
175
176 if t.Location == nil {
177 if _, err := cw.Write(cbg.CborNull); err != nil {
178 return err
179 }
180 } else {
181 if len(*t.Location) > 1000000 {
182 return xerrors.Errorf("Value in field t.Location was too long")
183 }
184
185 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Location))); err != nil {
186 return err
187 }
188 if _, err := cw.WriteString(string(*t.Location)); err != nil {
189 return err
190 }
191 }
192 }
193
194 // t.Description (string) (string)
195 if t.Description != nil {
196
197 if len("description") > 1000000 {
198 return xerrors.Errorf("Value in field \"description\" was too long")
199 }
200
201 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
202 return err
203 }
204 if _, err := cw.WriteString(string("description")); err != nil {
205 return err
206 }
207
208 if t.Description == nil {
209 if _, err := cw.Write(cbg.CborNull); err != nil {
210 return err
211 }
212 } else {
213 if len(*t.Description) > 1000000 {
214 return xerrors.Errorf("Value in field t.Description was too long")
215 }
216
217 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
218 return err
219 }
220 if _, err := cw.WriteString(string(*t.Description)); err != nil {
221 return err
222 }
223 }
224 }
225
226 // t.PinnedRepositories ([]string) (slice)
227 if t.PinnedRepositories != nil {
228
229 if len("pinnedRepositories") > 1000000 {
230 return xerrors.Errorf("Value in field \"pinnedRepositories\" was too long")
231 }
232
233 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pinnedRepositories"))); err != nil {
234 return err
235 }
236 if _, err := cw.WriteString(string("pinnedRepositories")); err != nil {
237 return err
238 }
239
240 if len(t.PinnedRepositories) > 8192 {
241 return xerrors.Errorf("Slice value in field t.PinnedRepositories was too long")
242 }
243
244 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.PinnedRepositories))); err != nil {
245 return err
246 }
247 for _, v := range t.PinnedRepositories {
248 if len(v) > 1000000 {
249 return xerrors.Errorf("Value in field v was too long")
250 }
251
252 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
253 return err
254 }
255 if _, err := cw.WriteString(string(v)); err != nil {
256 return err
257 }
258
259 }
260 }
261 return nil
262}
263
264func (t *ActorProfile) UnmarshalCBOR(r io.Reader) (err error) {
265 *t = ActorProfile{}
266
267 cr := cbg.NewCborReader(r)
268
269 maj, extra, err := cr.ReadHeader()
270 if err != nil {
271 return err
272 }
273 defer func() {
274 if err == io.EOF {
275 err = io.ErrUnexpectedEOF
276 }
277 }()
278
279 if maj != cbg.MajMap {
280 return fmt.Errorf("cbor input should be of type map")
281 }
282
283 if extra > cbg.MaxLength {
284 return fmt.Errorf("ActorProfile: map struct too large (%d)", extra)
285 }
286
287 n := extra
288
289 nameBuf := make([]byte, 18)
290 for i := uint64(0); i < n; i++ {
291 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
292 if err != nil {
293 return err
294 }
295
296 if !ok {
297 // Field doesn't exist on this type, so ignore it
298 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
299 return err
300 }
301 continue
302 }
303
304 switch string(nameBuf[:nameLen]) {
305 // t.LexiconTypeID (string) (string)
306 case "$type":
307
308 {
309 sval, err := cbg.ReadStringWithMax(cr, 1000000)
310 if err != nil {
311 return err
312 }
313
314 t.LexiconTypeID = string(sval)
315 }
316 // t.Links ([]string) (slice)
317 case "links":
318
319 maj, extra, err = cr.ReadHeader()
320 if err != nil {
321 return err
322 }
323
324 if extra > 8192 {
325 return fmt.Errorf("t.Links: array too large (%d)", extra)
326 }
327
328 if maj != cbg.MajArray {
329 return fmt.Errorf("expected cbor array")
330 }
331
332 if extra > 0 {
333 t.Links = make([]string, extra)
334 }
335
336 for i := 0; i < int(extra); i++ {
337 {
338 var maj byte
339 var extra uint64
340 var err error
341 _ = maj
342 _ = extra
343 _ = err
344
345 {
346 sval, err := cbg.ReadStringWithMax(cr, 1000000)
347 if err != nil {
348 return err
349 }
350
351 t.Links[i] = string(sval)
352 }
353
354 }
355 }
356 // t.Stats ([]string) (slice)
357 case "stats":
358
359 maj, extra, err = cr.ReadHeader()
360 if err != nil {
361 return err
362 }
363
364 if extra > 8192 {
365 return fmt.Errorf("t.Stats: array too large (%d)", extra)
366 }
367
368 if maj != cbg.MajArray {
369 return fmt.Errorf("expected cbor array")
370 }
371
372 if extra > 0 {
373 t.Stats = make([]string, extra)
374 }
375
376 for i := 0; i < int(extra); i++ {
377 {
378 var maj byte
379 var extra uint64
380 var err error
381 _ = maj
382 _ = extra
383 _ = err
384
385 {
386 sval, err := cbg.ReadStringWithMax(cr, 1000000)
387 if err != nil {
388 return err
389 }
390
391 t.Stats[i] = string(sval)
392 }
393
394 }
395 }
396 // t.Bluesky (bool) (bool)
397 case "bluesky":
398
399 maj, extra, err = cr.ReadHeader()
400 if err != nil {
401 return err
402 }
403 if maj != cbg.MajOther {
404 return fmt.Errorf("booleans must be major type 7")
405 }
406 switch extra {
407 case 20:
408 t.Bluesky = false
409 case 21:
410 t.Bluesky = true
411 default:
412 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
413 }
414 // t.Location (string) (string)
415 case "location":
416
417 {
418 b, err := cr.ReadByte()
419 if err != nil {
420 return err
421 }
422 if b != cbg.CborNull[0] {
423 if err := cr.UnreadByte(); err != nil {
424 return err
425 }
426
427 sval, err := cbg.ReadStringWithMax(cr, 1000000)
428 if err != nil {
429 return err
430 }
431
432 t.Location = (*string)(&sval)
433 }
434 }
435 // t.Description (string) (string)
436 case "description":
437
438 {
439 b, err := cr.ReadByte()
440 if err != nil {
441 return err
442 }
443 if b != cbg.CborNull[0] {
444 if err := cr.UnreadByte(); err != nil {
445 return err
446 }
447
448 sval, err := cbg.ReadStringWithMax(cr, 1000000)
449 if err != nil {
450 return err
451 }
452
453 t.Description = (*string)(&sval)
454 }
455 }
456 // t.PinnedRepositories ([]string) (slice)
457 case "pinnedRepositories":
458
459 maj, extra, err = cr.ReadHeader()
460 if err != nil {
461 return err
462 }
463
464 if extra > 8192 {
465 return fmt.Errorf("t.PinnedRepositories: array too large (%d)", extra)
466 }
467
468 if maj != cbg.MajArray {
469 return fmt.Errorf("expected cbor array")
470 }
471
472 if extra > 0 {
473 t.PinnedRepositories = make([]string, extra)
474 }
475
476 for i := 0; i < int(extra); i++ {
477 {
478 var maj byte
479 var extra uint64
480 var err error
481 _ = maj
482 _ = extra
483 _ = err
484
485 {
486 sval, err := cbg.ReadStringWithMax(cr, 1000000)
487 if err != nil {
488 return err
489 }
490
491 t.PinnedRepositories[i] = string(sval)
492 }
493
494 }
495 }
496
497 default:
498 // Field doesn't exist on this type, so ignore it
499 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
500 return err
501 }
502 }
503 }
504
505 return nil
506}
507func (t *FeedReaction) MarshalCBOR(w io.Writer) error {
508 if t == nil {
509 _, err := w.Write(cbg.CborNull)
510 return err
511 }
512
513 cw := cbg.NewCborWriter(w)
514
515 if _, err := cw.Write([]byte{164}); err != nil {
516 return err
517 }
518
519 // t.LexiconTypeID (string) (string)
520 if len("$type") > 1000000 {
521 return xerrors.Errorf("Value in field \"$type\" was too long")
522 }
523
524 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
525 return err
526 }
527 if _, err := cw.WriteString(string("$type")); err != nil {
528 return err
529 }
530
531 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.reaction"))); err != nil {
532 return err
533 }
534 if _, err := cw.WriteString(string("sh.tangled.feed.reaction")); err != nil {
535 return err
536 }
537
538 // t.Subject (string) (string)
539 if len("subject") > 1000000 {
540 return xerrors.Errorf("Value in field \"subject\" was too long")
541 }
542
543 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
544 return err
545 }
546 if _, err := cw.WriteString(string("subject")); err != nil {
547 return err
548 }
549
550 if len(t.Subject) > 1000000 {
551 return xerrors.Errorf("Value in field t.Subject was too long")
552 }
553
554 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
555 return err
556 }
557 if _, err := cw.WriteString(string(t.Subject)); err != nil {
558 return err
559 }
560
561 // t.Reaction (string) (string)
562 if len("reaction") > 1000000 {
563 return xerrors.Errorf("Value in field \"reaction\" was too long")
564 }
565
566 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("reaction"))); err != nil {
567 return err
568 }
569 if _, err := cw.WriteString(string("reaction")); err != nil {
570 return err
571 }
572
573 if len(t.Reaction) > 1000000 {
574 return xerrors.Errorf("Value in field t.Reaction was too long")
575 }
576
577 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Reaction))); err != nil {
578 return err
579 }
580 if _, err := cw.WriteString(string(t.Reaction)); err != nil {
581 return err
582 }
583
584 // t.CreatedAt (string) (string)
585 if len("createdAt") > 1000000 {
586 return xerrors.Errorf("Value in field \"createdAt\" was too long")
587 }
588
589 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
590 return err
591 }
592 if _, err := cw.WriteString(string("createdAt")); err != nil {
593 return err
594 }
595
596 if len(t.CreatedAt) > 1000000 {
597 return xerrors.Errorf("Value in field t.CreatedAt was too long")
598 }
599
600 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
601 return err
602 }
603 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
604 return err
605 }
606 return nil
607}
608
609func (t *FeedReaction) UnmarshalCBOR(r io.Reader) (err error) {
610 *t = FeedReaction{}
611
612 cr := cbg.NewCborReader(r)
613
614 maj, extra, err := cr.ReadHeader()
615 if err != nil {
616 return err
617 }
618 defer func() {
619 if err == io.EOF {
620 err = io.ErrUnexpectedEOF
621 }
622 }()
623
624 if maj != cbg.MajMap {
625 return fmt.Errorf("cbor input should be of type map")
626 }
627
628 if extra > cbg.MaxLength {
629 return fmt.Errorf("FeedReaction: map struct too large (%d)", extra)
630 }
631
632 n := extra
633
634 nameBuf := make([]byte, 9)
635 for i := uint64(0); i < n; i++ {
636 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
637 if err != nil {
638 return err
639 }
640
641 if !ok {
642 // Field doesn't exist on this type, so ignore it
643 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
644 return err
645 }
646 continue
647 }
648
649 switch string(nameBuf[:nameLen]) {
650 // t.LexiconTypeID (string) (string)
651 case "$type":
652
653 {
654 sval, err := cbg.ReadStringWithMax(cr, 1000000)
655 if err != nil {
656 return err
657 }
658
659 t.LexiconTypeID = string(sval)
660 }
661 // t.Subject (string) (string)
662 case "subject":
663
664 {
665 sval, err := cbg.ReadStringWithMax(cr, 1000000)
666 if err != nil {
667 return err
668 }
669
670 t.Subject = string(sval)
671 }
672 // t.Reaction (string) (string)
673 case "reaction":
674
675 {
676 sval, err := cbg.ReadStringWithMax(cr, 1000000)
677 if err != nil {
678 return err
679 }
680
681 t.Reaction = string(sval)
682 }
683 // t.CreatedAt (string) (string)
684 case "createdAt":
685
686 {
687 sval, err := cbg.ReadStringWithMax(cr, 1000000)
688 if err != nil {
689 return err
690 }
691
692 t.CreatedAt = string(sval)
693 }
694
695 default:
696 // Field doesn't exist on this type, so ignore it
697 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
698 return err
699 }
700 }
701 }
702
703 return nil
704}
705func (t *FeedStar) MarshalCBOR(w io.Writer) error {
706 if t == nil {
707 _, err := w.Write(cbg.CborNull)
708 return err
709 }
710
711 cw := cbg.NewCborWriter(w)
712
713 if _, err := cw.Write([]byte{163}); err != nil {
714 return err
715 }
716
717 // t.LexiconTypeID (string) (string)
718 if len("$type") > 1000000 {
719 return xerrors.Errorf("Value in field \"$type\" was too long")
720 }
721
722 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
723 return err
724 }
725 if _, err := cw.WriteString(string("$type")); err != nil {
726 return err
727 }
728
729 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.star"))); err != nil {
730 return err
731 }
732 if _, err := cw.WriteString(string("sh.tangled.feed.star")); err != nil {
733 return err
734 }
735
736 // t.Subject (string) (string)
737 if len("subject") > 1000000 {
738 return xerrors.Errorf("Value in field \"subject\" was too long")
739 }
740
741 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
742 return err
743 }
744 if _, err := cw.WriteString(string("subject")); err != nil {
745 return err
746 }
747
748 if len(t.Subject) > 1000000 {
749 return xerrors.Errorf("Value in field t.Subject was too long")
750 }
751
752 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
753 return err
754 }
755 if _, err := cw.WriteString(string(t.Subject)); err != nil {
756 return err
757 }
758
759 // t.CreatedAt (string) (string)
760 if len("createdAt") > 1000000 {
761 return xerrors.Errorf("Value in field \"createdAt\" was too long")
762 }
763
764 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
765 return err
766 }
767 if _, err := cw.WriteString(string("createdAt")); err != nil {
768 return err
769 }
770
771 if len(t.CreatedAt) > 1000000 {
772 return xerrors.Errorf("Value in field t.CreatedAt was too long")
773 }
774
775 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
776 return err
777 }
778 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
779 return err
780 }
781 return nil
782}
783
784func (t *FeedStar) UnmarshalCBOR(r io.Reader) (err error) {
785 *t = FeedStar{}
786
787 cr := cbg.NewCborReader(r)
788
789 maj, extra, err := cr.ReadHeader()
790 if err != nil {
791 return err
792 }
793 defer func() {
794 if err == io.EOF {
795 err = io.ErrUnexpectedEOF
796 }
797 }()
798
799 if maj != cbg.MajMap {
800 return fmt.Errorf("cbor input should be of type map")
801 }
802
803 if extra > cbg.MaxLength {
804 return fmt.Errorf("FeedStar: map struct too large (%d)", extra)
805 }
806
807 n := extra
808
809 nameBuf := make([]byte, 9)
810 for i := uint64(0); i < n; i++ {
811 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
812 if err != nil {
813 return err
814 }
815
816 if !ok {
817 // Field doesn't exist on this type, so ignore it
818 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
819 return err
820 }
821 continue
822 }
823
824 switch string(nameBuf[:nameLen]) {
825 // t.LexiconTypeID (string) (string)
826 case "$type":
827
828 {
829 sval, err := cbg.ReadStringWithMax(cr, 1000000)
830 if err != nil {
831 return err
832 }
833
834 t.LexiconTypeID = string(sval)
835 }
836 // t.Subject (string) (string)
837 case "subject":
838
839 {
840 sval, err := cbg.ReadStringWithMax(cr, 1000000)
841 if err != nil {
842 return err
843 }
844
845 t.Subject = string(sval)
846 }
847 // t.CreatedAt (string) (string)
848 case "createdAt":
849
850 {
851 sval, err := cbg.ReadStringWithMax(cr, 1000000)
852 if err != nil {
853 return err
854 }
855
856 t.CreatedAt = string(sval)
857 }
858
859 default:
860 // Field doesn't exist on this type, so ignore it
861 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
862 return err
863 }
864 }
865 }
866
867 return nil
868}
869func (t *GitRefUpdate) MarshalCBOR(w io.Writer) error {
870 if t == nil {
871 _, err := w.Write(cbg.CborNull)
872 return err
873 }
874
875 cw := cbg.NewCborWriter(w)
876
877 if _, err := cw.Write([]byte{168}); err != nil {
878 return err
879 }
880
881 // t.Ref (string) (string)
882 if len("ref") > 1000000 {
883 return xerrors.Errorf("Value in field \"ref\" was too long")
884 }
885
886 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
887 return err
888 }
889 if _, err := cw.WriteString(string("ref")); err != nil {
890 return err
891 }
892
893 if len(t.Ref) > 1000000 {
894 return xerrors.Errorf("Value in field t.Ref was too long")
895 }
896
897 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
898 return err
899 }
900 if _, err := cw.WriteString(string(t.Ref)); err != nil {
901 return err
902 }
903
904 // t.Meta (tangled.GitRefUpdate_Meta) (struct)
905 if len("meta") > 1000000 {
906 return xerrors.Errorf("Value in field \"meta\" was too long")
907 }
908
909 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil {
910 return err
911 }
912 if _, err := cw.WriteString(string("meta")); err != nil {
913 return err
914 }
915
916 if err := t.Meta.MarshalCBOR(cw); err != nil {
917 return err
918 }
919
920 // t.LexiconTypeID (string) (string)
921 if len("$type") > 1000000 {
922 return xerrors.Errorf("Value in field \"$type\" was too long")
923 }
924
925 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
926 return err
927 }
928 if _, err := cw.WriteString(string("$type")); err != nil {
929 return err
930 }
931
932 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.git.refUpdate"))); err != nil {
933 return err
934 }
935 if _, err := cw.WriteString(string("sh.tangled.git.refUpdate")); err != nil {
936 return err
937 }
938
939 // t.NewSha (string) (string)
940 if len("newSha") > 1000000 {
941 return xerrors.Errorf("Value in field \"newSha\" was too long")
942 }
943
944 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
945 return err
946 }
947 if _, err := cw.WriteString(string("newSha")); err != nil {
948 return err
949 }
950
951 if len(t.NewSha) > 1000000 {
952 return xerrors.Errorf("Value in field t.NewSha was too long")
953 }
954
955 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
956 return err
957 }
958 if _, err := cw.WriteString(string(t.NewSha)); err != nil {
959 return err
960 }
961
962 // t.OldSha (string) (string)
963 if len("oldSha") > 1000000 {
964 return xerrors.Errorf("Value in field \"oldSha\" was too long")
965 }
966
967 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
968 return err
969 }
970 if _, err := cw.WriteString(string("oldSha")); err != nil {
971 return err
972 }
973
974 if len(t.OldSha) > 1000000 {
975 return xerrors.Errorf("Value in field t.OldSha was too long")
976 }
977
978 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
979 return err
980 }
981 if _, err := cw.WriteString(string(t.OldSha)); err != nil {
982 return err
983 }
984
985 // t.RepoDid (string) (string)
986 if len("repoDid") > 1000000 {
987 return xerrors.Errorf("Value in field \"repoDid\" was too long")
988 }
989
990 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
991 return err
992 }
993 if _, err := cw.WriteString(string("repoDid")); err != nil {
994 return err
995 }
996
997 if len(t.RepoDid) > 1000000 {
998 return xerrors.Errorf("Value in field t.RepoDid was too long")
999 }
1000
1001 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoDid))); err != nil {
1002 return err
1003 }
1004 if _, err := cw.WriteString(string(t.RepoDid)); err != nil {
1005 return err
1006 }
1007
1008 // t.RepoName (string) (string)
1009 if len("repoName") > 1000000 {
1010 return xerrors.Errorf("Value in field \"repoName\" was too long")
1011 }
1012
1013 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoName"))); err != nil {
1014 return err
1015 }
1016 if _, err := cw.WriteString(string("repoName")); err != nil {
1017 return err
1018 }
1019
1020 if len(t.RepoName) > 1000000 {
1021 return xerrors.Errorf("Value in field t.RepoName was too long")
1022 }
1023
1024 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoName))); err != nil {
1025 return err
1026 }
1027 if _, err := cw.WriteString(string(t.RepoName)); err != nil {
1028 return err
1029 }
1030
1031 // t.CommitterDid (string) (string)
1032 if len("committerDid") > 1000000 {
1033 return xerrors.Errorf("Value in field \"committerDid\" was too long")
1034 }
1035
1036 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("committerDid"))); err != nil {
1037 return err
1038 }
1039 if _, err := cw.WriteString(string("committerDid")); err != nil {
1040 return err
1041 }
1042
1043 if len(t.CommitterDid) > 1000000 {
1044 return xerrors.Errorf("Value in field t.CommitterDid was too long")
1045 }
1046
1047 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CommitterDid))); err != nil {
1048 return err
1049 }
1050 if _, err := cw.WriteString(string(t.CommitterDid)); err != nil {
1051 return err
1052 }
1053 return nil
1054}
1055
1056func (t *GitRefUpdate) UnmarshalCBOR(r io.Reader) (err error) {
1057 *t = GitRefUpdate{}
1058
1059 cr := cbg.NewCborReader(r)
1060
1061 maj, extra, err := cr.ReadHeader()
1062 if err != nil {
1063 return err
1064 }
1065 defer func() {
1066 if err == io.EOF {
1067 err = io.ErrUnexpectedEOF
1068 }
1069 }()
1070
1071 if maj != cbg.MajMap {
1072 return fmt.Errorf("cbor input should be of type map")
1073 }
1074
1075 if extra > cbg.MaxLength {
1076 return fmt.Errorf("GitRefUpdate: map struct too large (%d)", extra)
1077 }
1078
1079 n := extra
1080
1081 nameBuf := make([]byte, 12)
1082 for i := uint64(0); i < n; i++ {
1083 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1084 if err != nil {
1085 return err
1086 }
1087
1088 if !ok {
1089 // Field doesn't exist on this type, so ignore it
1090 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1091 return err
1092 }
1093 continue
1094 }
1095
1096 switch string(nameBuf[:nameLen]) {
1097 // t.Ref (string) (string)
1098 case "ref":
1099
1100 {
1101 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1102 if err != nil {
1103 return err
1104 }
1105
1106 t.Ref = string(sval)
1107 }
1108 // t.Meta (tangled.GitRefUpdate_Meta) (struct)
1109 case "meta":
1110
1111 {
1112
1113 b, err := cr.ReadByte()
1114 if err != nil {
1115 return err
1116 }
1117 if b != cbg.CborNull[0] {
1118 if err := cr.UnreadByte(); err != nil {
1119 return err
1120 }
1121 t.Meta = new(GitRefUpdate_Meta)
1122 if err := t.Meta.UnmarshalCBOR(cr); err != nil {
1123 return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err)
1124 }
1125 }
1126
1127 }
1128 // t.LexiconTypeID (string) (string)
1129 case "$type":
1130
1131 {
1132 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1133 if err != nil {
1134 return err
1135 }
1136
1137 t.LexiconTypeID = string(sval)
1138 }
1139 // t.NewSha (string) (string)
1140 case "newSha":
1141
1142 {
1143 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1144 if err != nil {
1145 return err
1146 }
1147
1148 t.NewSha = string(sval)
1149 }
1150 // t.OldSha (string) (string)
1151 case "oldSha":
1152
1153 {
1154 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1155 if err != nil {
1156 return err
1157 }
1158
1159 t.OldSha = string(sval)
1160 }
1161 // t.RepoDid (string) (string)
1162 case "repoDid":
1163
1164 {
1165 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1166 if err != nil {
1167 return err
1168 }
1169
1170 t.RepoDid = string(sval)
1171 }
1172 // t.RepoName (string) (string)
1173 case "repoName":
1174
1175 {
1176 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1177 if err != nil {
1178 return err
1179 }
1180
1181 t.RepoName = string(sval)
1182 }
1183 // t.CommitterDid (string) (string)
1184 case "committerDid":
1185
1186 {
1187 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1188 if err != nil {
1189 return err
1190 }
1191
1192 t.CommitterDid = string(sval)
1193 }
1194
1195 default:
1196 // Field doesn't exist on this type, so ignore it
1197 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1198 return err
1199 }
1200 }
1201 }
1202
1203 return nil
1204}
1205func (t *GitRefUpdate_CommitCountBreakdown) MarshalCBOR(w io.Writer) error {
1206 if t == nil {
1207 _, err := w.Write(cbg.CborNull)
1208 return err
1209 }
1210
1211 cw := cbg.NewCborWriter(w)
1212 fieldCount := 1
1213
1214 if t.ByEmail == nil {
1215 fieldCount--
1216 }
1217
1218 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1219 return err
1220 }
1221
1222 // t.ByEmail ([]*tangled.GitRefUpdate_IndividualEmailCommitCount) (slice)
1223 if t.ByEmail != nil {
1224
1225 if len("byEmail") > 1000000 {
1226 return xerrors.Errorf("Value in field \"byEmail\" was too long")
1227 }
1228
1229 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byEmail"))); err != nil {
1230 return err
1231 }
1232 if _, err := cw.WriteString(string("byEmail")); err != nil {
1233 return err
1234 }
1235
1236 if len(t.ByEmail) > 8192 {
1237 return xerrors.Errorf("Slice value in field t.ByEmail was too long")
1238 }
1239
1240 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ByEmail))); err != nil {
1241 return err
1242 }
1243 for _, v := range t.ByEmail {
1244 if err := v.MarshalCBOR(cw); err != nil {
1245 return err
1246 }
1247
1248 }
1249 }
1250 return nil
1251}
1252
1253func (t *GitRefUpdate_CommitCountBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
1254 *t = GitRefUpdate_CommitCountBreakdown{}
1255
1256 cr := cbg.NewCborReader(r)
1257
1258 maj, extra, err := cr.ReadHeader()
1259 if err != nil {
1260 return err
1261 }
1262 defer func() {
1263 if err == io.EOF {
1264 err = io.ErrUnexpectedEOF
1265 }
1266 }()
1267
1268 if maj != cbg.MajMap {
1269 return fmt.Errorf("cbor input should be of type map")
1270 }
1271
1272 if extra > cbg.MaxLength {
1273 return fmt.Errorf("GitRefUpdate_CommitCountBreakdown: map struct too large (%d)", extra)
1274 }
1275
1276 n := extra
1277
1278 nameBuf := make([]byte, 7)
1279 for i := uint64(0); i < n; i++ {
1280 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1281 if err != nil {
1282 return err
1283 }
1284
1285 if !ok {
1286 // Field doesn't exist on this type, so ignore it
1287 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1288 return err
1289 }
1290 continue
1291 }
1292
1293 switch string(nameBuf[:nameLen]) {
1294 // t.ByEmail ([]*tangled.GitRefUpdate_IndividualEmailCommitCount) (slice)
1295 case "byEmail":
1296
1297 maj, extra, err = cr.ReadHeader()
1298 if err != nil {
1299 return err
1300 }
1301
1302 if extra > 8192 {
1303 return fmt.Errorf("t.ByEmail: array too large (%d)", extra)
1304 }
1305
1306 if maj != cbg.MajArray {
1307 return fmt.Errorf("expected cbor array")
1308 }
1309
1310 if extra > 0 {
1311 t.ByEmail = make([]*GitRefUpdate_IndividualEmailCommitCount, extra)
1312 }
1313
1314 for i := 0; i < int(extra); i++ {
1315 {
1316 var maj byte
1317 var extra uint64
1318 var err error
1319 _ = maj
1320 _ = extra
1321 _ = err
1322
1323 {
1324
1325 b, err := cr.ReadByte()
1326 if err != nil {
1327 return err
1328 }
1329 if b != cbg.CborNull[0] {
1330 if err := cr.UnreadByte(); err != nil {
1331 return err
1332 }
1333 t.ByEmail[i] = new(GitRefUpdate_IndividualEmailCommitCount)
1334 if err := t.ByEmail[i].UnmarshalCBOR(cr); err != nil {
1335 return xerrors.Errorf("unmarshaling t.ByEmail[i] pointer: %w", err)
1336 }
1337 }
1338
1339 }
1340
1341 }
1342 }
1343
1344 default:
1345 // Field doesn't exist on this type, so ignore it
1346 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1347 return err
1348 }
1349 }
1350 }
1351
1352 return nil
1353}
1354func (t *GitRefUpdate_IndividualEmailCommitCount) MarshalCBOR(w io.Writer) error {
1355 if t == nil {
1356 _, err := w.Write(cbg.CborNull)
1357 return err
1358 }
1359
1360 cw := cbg.NewCborWriter(w)
1361
1362 if _, err := cw.Write([]byte{162}); err != nil {
1363 return err
1364 }
1365
1366 // t.Count (int64) (int64)
1367 if len("count") > 1000000 {
1368 return xerrors.Errorf("Value in field \"count\" was too long")
1369 }
1370
1371 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("count"))); err != nil {
1372 return err
1373 }
1374 if _, err := cw.WriteString(string("count")); err != nil {
1375 return err
1376 }
1377
1378 if t.Count >= 0 {
1379 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Count)); err != nil {
1380 return err
1381 }
1382 } else {
1383 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Count-1)); err != nil {
1384 return err
1385 }
1386 }
1387
1388 // t.Email (string) (string)
1389 if len("email") > 1000000 {
1390 return xerrors.Errorf("Value in field \"email\" was too long")
1391 }
1392
1393 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("email"))); err != nil {
1394 return err
1395 }
1396 if _, err := cw.WriteString(string("email")); err != nil {
1397 return err
1398 }
1399
1400 if len(t.Email) > 1000000 {
1401 return xerrors.Errorf("Value in field t.Email was too long")
1402 }
1403
1404 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Email))); err != nil {
1405 return err
1406 }
1407 if _, err := cw.WriteString(string(t.Email)); err != nil {
1408 return err
1409 }
1410 return nil
1411}
1412
1413func (t *GitRefUpdate_IndividualEmailCommitCount) UnmarshalCBOR(r io.Reader) (err error) {
1414 *t = GitRefUpdate_IndividualEmailCommitCount{}
1415
1416 cr := cbg.NewCborReader(r)
1417
1418 maj, extra, err := cr.ReadHeader()
1419 if err != nil {
1420 return err
1421 }
1422 defer func() {
1423 if err == io.EOF {
1424 err = io.ErrUnexpectedEOF
1425 }
1426 }()
1427
1428 if maj != cbg.MajMap {
1429 return fmt.Errorf("cbor input should be of type map")
1430 }
1431
1432 if extra > cbg.MaxLength {
1433 return fmt.Errorf("GitRefUpdate_IndividualEmailCommitCount: map struct too large (%d)", extra)
1434 }
1435
1436 n := extra
1437
1438 nameBuf := make([]byte, 5)
1439 for i := uint64(0); i < n; i++ {
1440 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1441 if err != nil {
1442 return err
1443 }
1444
1445 if !ok {
1446 // Field doesn't exist on this type, so ignore it
1447 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1448 return err
1449 }
1450 continue
1451 }
1452
1453 switch string(nameBuf[:nameLen]) {
1454 // t.Count (int64) (int64)
1455 case "count":
1456 {
1457 maj, extra, err := cr.ReadHeader()
1458 if err != nil {
1459 return err
1460 }
1461 var extraI int64
1462 switch maj {
1463 case cbg.MajUnsignedInt:
1464 extraI = int64(extra)
1465 if extraI < 0 {
1466 return fmt.Errorf("int64 positive overflow")
1467 }
1468 case cbg.MajNegativeInt:
1469 extraI = int64(extra)
1470 if extraI < 0 {
1471 return fmt.Errorf("int64 negative overflow")
1472 }
1473 extraI = -1 - extraI
1474 default:
1475 return fmt.Errorf("wrong type for int64 field: %d", maj)
1476 }
1477
1478 t.Count = int64(extraI)
1479 }
1480 // t.Email (string) (string)
1481 case "email":
1482
1483 {
1484 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1485 if err != nil {
1486 return err
1487 }
1488
1489 t.Email = string(sval)
1490 }
1491
1492 default:
1493 // Field doesn't exist on this type, so ignore it
1494 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1495 return err
1496 }
1497 }
1498 }
1499
1500 return nil
1501}
1502func (t *GitRefUpdate_IndividualLanguageSize) MarshalCBOR(w io.Writer) error {
1503 if t == nil {
1504 _, err := w.Write(cbg.CborNull)
1505 return err
1506 }
1507
1508 cw := cbg.NewCborWriter(w)
1509
1510 if _, err := cw.Write([]byte{162}); err != nil {
1511 return err
1512 }
1513
1514 // t.Lang (string) (string)
1515 if len("lang") > 1000000 {
1516 return xerrors.Errorf("Value in field \"lang\" was too long")
1517 }
1518
1519 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil {
1520 return err
1521 }
1522 if _, err := cw.WriteString(string("lang")); err != nil {
1523 return err
1524 }
1525
1526 if len(t.Lang) > 1000000 {
1527 return xerrors.Errorf("Value in field t.Lang was too long")
1528 }
1529
1530 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil {
1531 return err
1532 }
1533 if _, err := cw.WriteString(string(t.Lang)); err != nil {
1534 return err
1535 }
1536
1537 // t.Size (int64) (int64)
1538 if len("size") > 1000000 {
1539 return xerrors.Errorf("Value in field \"size\" was too long")
1540 }
1541
1542 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil {
1543 return err
1544 }
1545 if _, err := cw.WriteString(string("size")); err != nil {
1546 return err
1547 }
1548
1549 if t.Size >= 0 {
1550 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil {
1551 return err
1552 }
1553 } else {
1554 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); err != nil {
1555 return err
1556 }
1557 }
1558
1559 return nil
1560}
1561
1562func (t *GitRefUpdate_IndividualLanguageSize) UnmarshalCBOR(r io.Reader) (err error) {
1563 *t = GitRefUpdate_IndividualLanguageSize{}
1564
1565 cr := cbg.NewCborReader(r)
1566
1567 maj, extra, err := cr.ReadHeader()
1568 if err != nil {
1569 return err
1570 }
1571 defer func() {
1572 if err == io.EOF {
1573 err = io.ErrUnexpectedEOF
1574 }
1575 }()
1576
1577 if maj != cbg.MajMap {
1578 return fmt.Errorf("cbor input should be of type map")
1579 }
1580
1581 if extra > cbg.MaxLength {
1582 return fmt.Errorf("GitRefUpdate_IndividualLanguageSize: map struct too large (%d)", extra)
1583 }
1584
1585 n := extra
1586
1587 nameBuf := make([]byte, 4)
1588 for i := uint64(0); i < n; i++ {
1589 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1590 if err != nil {
1591 return err
1592 }
1593
1594 if !ok {
1595 // Field doesn't exist on this type, so ignore it
1596 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1597 return err
1598 }
1599 continue
1600 }
1601
1602 switch string(nameBuf[:nameLen]) {
1603 // t.Lang (string) (string)
1604 case "lang":
1605
1606 {
1607 sval, err := cbg.ReadStringWithMax(cr, 1000000)
1608 if err != nil {
1609 return err
1610 }
1611
1612 t.Lang = string(sval)
1613 }
1614 // t.Size (int64) (int64)
1615 case "size":
1616 {
1617 maj, extra, err := cr.ReadHeader()
1618 if err != nil {
1619 return err
1620 }
1621 var extraI int64
1622 switch maj {
1623 case cbg.MajUnsignedInt:
1624 extraI = int64(extra)
1625 if extraI < 0 {
1626 return fmt.Errorf("int64 positive overflow")
1627 }
1628 case cbg.MajNegativeInt:
1629 extraI = int64(extra)
1630 if extraI < 0 {
1631 return fmt.Errorf("int64 negative overflow")
1632 }
1633 extraI = -1 - extraI
1634 default:
1635 return fmt.Errorf("wrong type for int64 field: %d", maj)
1636 }
1637
1638 t.Size = int64(extraI)
1639 }
1640
1641 default:
1642 // Field doesn't exist on this type, so ignore it
1643 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1644 return err
1645 }
1646 }
1647 }
1648
1649 return nil
1650}
1651func (t *GitRefUpdate_LangBreakdown) MarshalCBOR(w io.Writer) error {
1652 if t == nil {
1653 _, err := w.Write(cbg.CborNull)
1654 return err
1655 }
1656
1657 cw := cbg.NewCborWriter(w)
1658 fieldCount := 1
1659
1660 if t.Inputs == nil {
1661 fieldCount--
1662 }
1663
1664 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1665 return err
1666 }
1667
1668 // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice)
1669 if t.Inputs != nil {
1670
1671 if len("inputs") > 1000000 {
1672 return xerrors.Errorf("Value in field \"inputs\" was too long")
1673 }
1674
1675 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
1676 return err
1677 }
1678 if _, err := cw.WriteString(string("inputs")); err != nil {
1679 return err
1680 }
1681
1682 if len(t.Inputs) > 8192 {
1683 return xerrors.Errorf("Slice value in field t.Inputs was too long")
1684 }
1685
1686 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
1687 return err
1688 }
1689 for _, v := range t.Inputs {
1690 if err := v.MarshalCBOR(cw); err != nil {
1691 return err
1692 }
1693
1694 }
1695 }
1696 return nil
1697}
1698
1699func (t *GitRefUpdate_LangBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
1700 *t = GitRefUpdate_LangBreakdown{}
1701
1702 cr := cbg.NewCborReader(r)
1703
1704 maj, extra, err := cr.ReadHeader()
1705 if err != nil {
1706 return err
1707 }
1708 defer func() {
1709 if err == io.EOF {
1710 err = io.ErrUnexpectedEOF
1711 }
1712 }()
1713
1714 if maj != cbg.MajMap {
1715 return fmt.Errorf("cbor input should be of type map")
1716 }
1717
1718 if extra > cbg.MaxLength {
1719 return fmt.Errorf("GitRefUpdate_LangBreakdown: map struct too large (%d)", extra)
1720 }
1721
1722 n := extra
1723
1724 nameBuf := make([]byte, 6)
1725 for i := uint64(0); i < n; i++ {
1726 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1727 if err != nil {
1728 return err
1729 }
1730
1731 if !ok {
1732 // Field doesn't exist on this type, so ignore it
1733 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1734 return err
1735 }
1736 continue
1737 }
1738
1739 switch string(nameBuf[:nameLen]) {
1740 // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice)
1741 case "inputs":
1742
1743 maj, extra, err = cr.ReadHeader()
1744 if err != nil {
1745 return err
1746 }
1747
1748 if extra > 8192 {
1749 return fmt.Errorf("t.Inputs: array too large (%d)", extra)
1750 }
1751
1752 if maj != cbg.MajArray {
1753 return fmt.Errorf("expected cbor array")
1754 }
1755
1756 if extra > 0 {
1757 t.Inputs = make([]*GitRefUpdate_IndividualLanguageSize, extra)
1758 }
1759
1760 for i := 0; i < int(extra); i++ {
1761 {
1762 var maj byte
1763 var extra uint64
1764 var err error
1765 _ = maj
1766 _ = extra
1767 _ = err
1768
1769 {
1770
1771 b, err := cr.ReadByte()
1772 if err != nil {
1773 return err
1774 }
1775 if b != cbg.CborNull[0] {
1776 if err := cr.UnreadByte(); err != nil {
1777 return err
1778 }
1779 t.Inputs[i] = new(GitRefUpdate_IndividualLanguageSize)
1780 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
1781 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
1782 }
1783 }
1784
1785 }
1786
1787 }
1788 }
1789
1790 default:
1791 // Field doesn't exist on this type, so ignore it
1792 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1793 return err
1794 }
1795 }
1796 }
1797
1798 return nil
1799}
1800func (t *GitRefUpdate_Meta) MarshalCBOR(w io.Writer) error {
1801 if t == nil {
1802 _, err := w.Write(cbg.CborNull)
1803 return err
1804 }
1805
1806 cw := cbg.NewCborWriter(w)
1807 fieldCount := 3
1808
1809 if t.LangBreakdown == nil {
1810 fieldCount--
1811 }
1812
1813 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1814 return err
1815 }
1816
1817 // t.CommitCount (tangled.GitRefUpdate_CommitCountBreakdown) (struct)
1818 if len("commitCount") > 1000000 {
1819 return xerrors.Errorf("Value in field \"commitCount\" was too long")
1820 }
1821
1822 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commitCount"))); err != nil {
1823 return err
1824 }
1825 if _, err := cw.WriteString(string("commitCount")); err != nil {
1826 return err
1827 }
1828
1829 if err := t.CommitCount.MarshalCBOR(cw); err != nil {
1830 return err
1831 }
1832
1833 // t.IsDefaultRef (bool) (bool)
1834 if len("isDefaultRef") > 1000000 {
1835 return xerrors.Errorf("Value in field \"isDefaultRef\" was too long")
1836 }
1837
1838 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("isDefaultRef"))); err != nil {
1839 return err
1840 }
1841 if _, err := cw.WriteString(string("isDefaultRef")); err != nil {
1842 return err
1843 }
1844
1845 if err := cbg.WriteBool(w, t.IsDefaultRef); err != nil {
1846 return err
1847 }
1848
1849 // t.LangBreakdown (tangled.GitRefUpdate_LangBreakdown) (struct)
1850 if t.LangBreakdown != nil {
1851
1852 if len("langBreakdown") > 1000000 {
1853 return xerrors.Errorf("Value in field \"langBreakdown\" was too long")
1854 }
1855
1856 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("langBreakdown"))); err != nil {
1857 return err
1858 }
1859 if _, err := cw.WriteString(string("langBreakdown")); err != nil {
1860 return err
1861 }
1862
1863 if err := t.LangBreakdown.MarshalCBOR(cw); err != nil {
1864 return err
1865 }
1866 }
1867 return nil
1868}
1869
1870func (t *GitRefUpdate_Meta) UnmarshalCBOR(r io.Reader) (err error) {
1871 *t = GitRefUpdate_Meta{}
1872
1873 cr := cbg.NewCborReader(r)
1874
1875 maj, extra, err := cr.ReadHeader()
1876 if err != nil {
1877 return err
1878 }
1879 defer func() {
1880 if err == io.EOF {
1881 err = io.ErrUnexpectedEOF
1882 }
1883 }()
1884
1885 if maj != cbg.MajMap {
1886 return fmt.Errorf("cbor input should be of type map")
1887 }
1888
1889 if extra > cbg.MaxLength {
1890 return fmt.Errorf("GitRefUpdate_Meta: map struct too large (%d)", extra)
1891 }
1892
1893 n := extra
1894
1895 nameBuf := make([]byte, 13)
1896 for i := uint64(0); i < n; i++ {
1897 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1898 if err != nil {
1899 return err
1900 }
1901
1902 if !ok {
1903 // Field doesn't exist on this type, so ignore it
1904 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1905 return err
1906 }
1907 continue
1908 }
1909
1910 switch string(nameBuf[:nameLen]) {
1911 // t.CommitCount (tangled.GitRefUpdate_CommitCountBreakdown) (struct)
1912 case "commitCount":
1913
1914 {
1915
1916 b, err := cr.ReadByte()
1917 if err != nil {
1918 return err
1919 }
1920 if b != cbg.CborNull[0] {
1921 if err := cr.UnreadByte(); err != nil {
1922 return err
1923 }
1924 t.CommitCount = new(GitRefUpdate_CommitCountBreakdown)
1925 if err := t.CommitCount.UnmarshalCBOR(cr); err != nil {
1926 return xerrors.Errorf("unmarshaling t.CommitCount pointer: %w", err)
1927 }
1928 }
1929
1930 }
1931 // t.IsDefaultRef (bool) (bool)
1932 case "isDefaultRef":
1933
1934 maj, extra, err = cr.ReadHeader()
1935 if err != nil {
1936 return err
1937 }
1938 if maj != cbg.MajOther {
1939 return fmt.Errorf("booleans must be major type 7")
1940 }
1941 switch extra {
1942 case 20:
1943 t.IsDefaultRef = false
1944 case 21:
1945 t.IsDefaultRef = true
1946 default:
1947 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
1948 }
1949 // t.LangBreakdown (tangled.GitRefUpdate_LangBreakdown) (struct)
1950 case "langBreakdown":
1951
1952 {
1953
1954 b, err := cr.ReadByte()
1955 if err != nil {
1956 return err
1957 }
1958 if b != cbg.CborNull[0] {
1959 if err := cr.UnreadByte(); err != nil {
1960 return err
1961 }
1962 t.LangBreakdown = new(GitRefUpdate_LangBreakdown)
1963 if err := t.LangBreakdown.UnmarshalCBOR(cr); err != nil {
1964 return xerrors.Errorf("unmarshaling t.LangBreakdown pointer: %w", err)
1965 }
1966 }
1967
1968 }
1969
1970 default:
1971 // Field doesn't exist on this type, so ignore it
1972 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1973 return err
1974 }
1975 }
1976 }
1977
1978 return nil
1979}
1980func (t *GraphFollow) MarshalCBOR(w io.Writer) error {
1981 if t == nil {
1982 _, err := w.Write(cbg.CborNull)
1983 return err
1984 }
1985
1986 cw := cbg.NewCborWriter(w)
1987
1988 if _, err := cw.Write([]byte{163}); err != nil {
1989 return err
1990 }
1991
1992 // t.LexiconTypeID (string) (string)
1993 if len("$type") > 1000000 {
1994 return xerrors.Errorf("Value in field \"$type\" was too long")
1995 }
1996
1997 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
1998 return err
1999 }
2000 if _, err := cw.WriteString(string("$type")); err != nil {
2001 return err
2002 }
2003
2004 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.graph.follow"))); err != nil {
2005 return err
2006 }
2007 if _, err := cw.WriteString(string("sh.tangled.graph.follow")); err != nil {
2008 return err
2009 }
2010
2011 // t.Subject (string) (string)
2012 if len("subject") > 1000000 {
2013 return xerrors.Errorf("Value in field \"subject\" was too long")
2014 }
2015
2016 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
2017 return err
2018 }
2019 if _, err := cw.WriteString(string("subject")); err != nil {
2020 return err
2021 }
2022
2023 if len(t.Subject) > 1000000 {
2024 return xerrors.Errorf("Value in field t.Subject was too long")
2025 }
2026
2027 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
2028 return err
2029 }
2030 if _, err := cw.WriteString(string(t.Subject)); err != nil {
2031 return err
2032 }
2033
2034 // t.CreatedAt (string) (string)
2035 if len("createdAt") > 1000000 {
2036 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2037 }
2038
2039 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2040 return err
2041 }
2042 if _, err := cw.WriteString(string("createdAt")); err != nil {
2043 return err
2044 }
2045
2046 if len(t.CreatedAt) > 1000000 {
2047 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2048 }
2049
2050 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2051 return err
2052 }
2053 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2054 return err
2055 }
2056 return nil
2057}
2058
2059func (t *GraphFollow) UnmarshalCBOR(r io.Reader) (err error) {
2060 *t = GraphFollow{}
2061
2062 cr := cbg.NewCborReader(r)
2063
2064 maj, extra, err := cr.ReadHeader()
2065 if err != nil {
2066 return err
2067 }
2068 defer func() {
2069 if err == io.EOF {
2070 err = io.ErrUnexpectedEOF
2071 }
2072 }()
2073
2074 if maj != cbg.MajMap {
2075 return fmt.Errorf("cbor input should be of type map")
2076 }
2077
2078 if extra > cbg.MaxLength {
2079 return fmt.Errorf("GraphFollow: map struct too large (%d)", extra)
2080 }
2081
2082 n := extra
2083
2084 nameBuf := make([]byte, 9)
2085 for i := uint64(0); i < n; i++ {
2086 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2087 if err != nil {
2088 return err
2089 }
2090
2091 if !ok {
2092 // Field doesn't exist on this type, so ignore it
2093 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2094 return err
2095 }
2096 continue
2097 }
2098
2099 switch string(nameBuf[:nameLen]) {
2100 // t.LexiconTypeID (string) (string)
2101 case "$type":
2102
2103 {
2104 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2105 if err != nil {
2106 return err
2107 }
2108
2109 t.LexiconTypeID = string(sval)
2110 }
2111 // t.Subject (string) (string)
2112 case "subject":
2113
2114 {
2115 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2116 if err != nil {
2117 return err
2118 }
2119
2120 t.Subject = string(sval)
2121 }
2122 // t.CreatedAt (string) (string)
2123 case "createdAt":
2124
2125 {
2126 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2127 if err != nil {
2128 return err
2129 }
2130
2131 t.CreatedAt = string(sval)
2132 }
2133
2134 default:
2135 // Field doesn't exist on this type, so ignore it
2136 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2137 return err
2138 }
2139 }
2140 }
2141
2142 return nil
2143}
2144func (t *Knot) MarshalCBOR(w io.Writer) error {
2145 if t == nil {
2146 _, err := w.Write(cbg.CborNull)
2147 return err
2148 }
2149
2150 cw := cbg.NewCborWriter(w)
2151
2152 if _, err := cw.Write([]byte{162}); err != nil {
2153 return err
2154 }
2155
2156 // t.LexiconTypeID (string) (string)
2157 if len("$type") > 1000000 {
2158 return xerrors.Errorf("Value in field \"$type\" was too long")
2159 }
2160
2161 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2162 return err
2163 }
2164 if _, err := cw.WriteString(string("$type")); err != nil {
2165 return err
2166 }
2167
2168 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot"))); err != nil {
2169 return err
2170 }
2171 if _, err := cw.WriteString(string("sh.tangled.knot")); err != nil {
2172 return err
2173 }
2174
2175 // t.CreatedAt (string) (string)
2176 if len("createdAt") > 1000000 {
2177 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2178 }
2179
2180 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2181 return err
2182 }
2183 if _, err := cw.WriteString(string("createdAt")); err != nil {
2184 return err
2185 }
2186
2187 if len(t.CreatedAt) > 1000000 {
2188 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2189 }
2190
2191 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2192 return err
2193 }
2194 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2195 return err
2196 }
2197 return nil
2198}
2199
2200func (t *Knot) UnmarshalCBOR(r io.Reader) (err error) {
2201 *t = Knot{}
2202
2203 cr := cbg.NewCborReader(r)
2204
2205 maj, extra, err := cr.ReadHeader()
2206 if err != nil {
2207 return err
2208 }
2209 defer func() {
2210 if err == io.EOF {
2211 err = io.ErrUnexpectedEOF
2212 }
2213 }()
2214
2215 if maj != cbg.MajMap {
2216 return fmt.Errorf("cbor input should be of type map")
2217 }
2218
2219 if extra > cbg.MaxLength {
2220 return fmt.Errorf("Knot: map struct too large (%d)", extra)
2221 }
2222
2223 n := extra
2224
2225 nameBuf := make([]byte, 9)
2226 for i := uint64(0); i < n; i++ {
2227 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2228 if err != nil {
2229 return err
2230 }
2231
2232 if !ok {
2233 // Field doesn't exist on this type, so ignore it
2234 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2235 return err
2236 }
2237 continue
2238 }
2239
2240 switch string(nameBuf[:nameLen]) {
2241 // t.LexiconTypeID (string) (string)
2242 case "$type":
2243
2244 {
2245 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2246 if err != nil {
2247 return err
2248 }
2249
2250 t.LexiconTypeID = string(sval)
2251 }
2252 // t.CreatedAt (string) (string)
2253 case "createdAt":
2254
2255 {
2256 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2257 if err != nil {
2258 return err
2259 }
2260
2261 t.CreatedAt = string(sval)
2262 }
2263
2264 default:
2265 // Field doesn't exist on this type, so ignore it
2266 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2267 return err
2268 }
2269 }
2270 }
2271
2272 return nil
2273}
2274func (t *KnotMember) MarshalCBOR(w io.Writer) error {
2275 if t == nil {
2276 _, err := w.Write(cbg.CborNull)
2277 return err
2278 }
2279
2280 cw := cbg.NewCborWriter(w)
2281
2282 if _, err := cw.Write([]byte{164}); err != nil {
2283 return err
2284 }
2285
2286 // t.LexiconTypeID (string) (string)
2287 if len("$type") > 1000000 {
2288 return xerrors.Errorf("Value in field \"$type\" was too long")
2289 }
2290
2291 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2292 return err
2293 }
2294 if _, err := cw.WriteString(string("$type")); err != nil {
2295 return err
2296 }
2297
2298 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot.member"))); err != nil {
2299 return err
2300 }
2301 if _, err := cw.WriteString(string("sh.tangled.knot.member")); err != nil {
2302 return err
2303 }
2304
2305 // t.Domain (string) (string)
2306 if len("domain") > 1000000 {
2307 return xerrors.Errorf("Value in field \"domain\" was too long")
2308 }
2309
2310 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("domain"))); err != nil {
2311 return err
2312 }
2313 if _, err := cw.WriteString(string("domain")); err != nil {
2314 return err
2315 }
2316
2317 if len(t.Domain) > 1000000 {
2318 return xerrors.Errorf("Value in field t.Domain was too long")
2319 }
2320
2321 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Domain))); err != nil {
2322 return err
2323 }
2324 if _, err := cw.WriteString(string(t.Domain)); err != nil {
2325 return err
2326 }
2327
2328 // t.Subject (string) (string)
2329 if len("subject") > 1000000 {
2330 return xerrors.Errorf("Value in field \"subject\" was too long")
2331 }
2332
2333 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
2334 return err
2335 }
2336 if _, err := cw.WriteString(string("subject")); err != nil {
2337 return err
2338 }
2339
2340 if len(t.Subject) > 1000000 {
2341 return xerrors.Errorf("Value in field t.Subject was too long")
2342 }
2343
2344 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
2345 return err
2346 }
2347 if _, err := cw.WriteString(string(t.Subject)); err != nil {
2348 return err
2349 }
2350
2351 // t.CreatedAt (string) (string)
2352 if len("createdAt") > 1000000 {
2353 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2354 }
2355
2356 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2357 return err
2358 }
2359 if _, err := cw.WriteString(string("createdAt")); err != nil {
2360 return err
2361 }
2362
2363 if len(t.CreatedAt) > 1000000 {
2364 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2365 }
2366
2367 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2368 return err
2369 }
2370 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2371 return err
2372 }
2373 return nil
2374}
2375
2376func (t *KnotMember) UnmarshalCBOR(r io.Reader) (err error) {
2377 *t = KnotMember{}
2378
2379 cr := cbg.NewCborReader(r)
2380
2381 maj, extra, err := cr.ReadHeader()
2382 if err != nil {
2383 return err
2384 }
2385 defer func() {
2386 if err == io.EOF {
2387 err = io.ErrUnexpectedEOF
2388 }
2389 }()
2390
2391 if maj != cbg.MajMap {
2392 return fmt.Errorf("cbor input should be of type map")
2393 }
2394
2395 if extra > cbg.MaxLength {
2396 return fmt.Errorf("KnotMember: map struct too large (%d)", extra)
2397 }
2398
2399 n := extra
2400
2401 nameBuf := make([]byte, 9)
2402 for i := uint64(0); i < n; i++ {
2403 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2404 if err != nil {
2405 return err
2406 }
2407
2408 if !ok {
2409 // Field doesn't exist on this type, so ignore it
2410 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2411 return err
2412 }
2413 continue
2414 }
2415
2416 switch string(nameBuf[:nameLen]) {
2417 // t.LexiconTypeID (string) (string)
2418 case "$type":
2419
2420 {
2421 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2422 if err != nil {
2423 return err
2424 }
2425
2426 t.LexiconTypeID = string(sval)
2427 }
2428 // t.Domain (string) (string)
2429 case "domain":
2430
2431 {
2432 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2433 if err != nil {
2434 return err
2435 }
2436
2437 t.Domain = string(sval)
2438 }
2439 // t.Subject (string) (string)
2440 case "subject":
2441
2442 {
2443 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2444 if err != nil {
2445 return err
2446 }
2447
2448 t.Subject = string(sval)
2449 }
2450 // t.CreatedAt (string) (string)
2451 case "createdAt":
2452
2453 {
2454 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2455 if err != nil {
2456 return err
2457 }
2458
2459 t.CreatedAt = string(sval)
2460 }
2461
2462 default:
2463 // Field doesn't exist on this type, so ignore it
2464 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2465 return err
2466 }
2467 }
2468 }
2469
2470 return nil
2471}
2472func (t *LabelDefinition) MarshalCBOR(w io.Writer) error {
2473 if t == nil {
2474 _, err := w.Write(cbg.CborNull)
2475 return err
2476 }
2477
2478 cw := cbg.NewCborWriter(w)
2479 fieldCount := 7
2480
2481 if t.Color == nil {
2482 fieldCount--
2483 }
2484
2485 if t.Multiple == nil {
2486 fieldCount--
2487 }
2488
2489 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2490 return err
2491 }
2492
2493 // t.Name (string) (string)
2494 if len("name") > 1000000 {
2495 return xerrors.Errorf("Value in field \"name\" was too long")
2496 }
2497
2498 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
2499 return err
2500 }
2501 if _, err := cw.WriteString(string("name")); err != nil {
2502 return err
2503 }
2504
2505 if len(t.Name) > 1000000 {
2506 return xerrors.Errorf("Value in field t.Name was too long")
2507 }
2508
2509 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
2510 return err
2511 }
2512 if _, err := cw.WriteString(string(t.Name)); err != nil {
2513 return err
2514 }
2515
2516 // t.LexiconTypeID (string) (string)
2517 if len("$type") > 1000000 {
2518 return xerrors.Errorf("Value in field \"$type\" was too long")
2519 }
2520
2521 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2522 return err
2523 }
2524 if _, err := cw.WriteString(string("$type")); err != nil {
2525 return err
2526 }
2527
2528 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.definition"))); err != nil {
2529 return err
2530 }
2531 if _, err := cw.WriteString(string("sh.tangled.label.definition")); err != nil {
2532 return err
2533 }
2534
2535 // t.Color (string) (string)
2536 if t.Color != nil {
2537
2538 if len("color") > 1000000 {
2539 return xerrors.Errorf("Value in field \"color\" was too long")
2540 }
2541
2542 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("color"))); err != nil {
2543 return err
2544 }
2545 if _, err := cw.WriteString(string("color")); err != nil {
2546 return err
2547 }
2548
2549 if t.Color == nil {
2550 if _, err := cw.Write(cbg.CborNull); err != nil {
2551 return err
2552 }
2553 } else {
2554 if len(*t.Color) > 1000000 {
2555 return xerrors.Errorf("Value in field t.Color was too long")
2556 }
2557
2558 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Color))); err != nil {
2559 return err
2560 }
2561 if _, err := cw.WriteString(string(*t.Color)); err != nil {
2562 return err
2563 }
2564 }
2565 }
2566
2567 // t.Scope ([]string) (slice)
2568 if len("scope") > 1000000 {
2569 return xerrors.Errorf("Value in field \"scope\" was too long")
2570 }
2571
2572 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("scope"))); err != nil {
2573 return err
2574 }
2575 if _, err := cw.WriteString(string("scope")); err != nil {
2576 return err
2577 }
2578
2579 if len(t.Scope) > 8192 {
2580 return xerrors.Errorf("Slice value in field t.Scope was too long")
2581 }
2582
2583 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Scope))); err != nil {
2584 return err
2585 }
2586 for _, v := range t.Scope {
2587 if len(v) > 1000000 {
2588 return xerrors.Errorf("Value in field v was too long")
2589 }
2590
2591 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
2592 return err
2593 }
2594 if _, err := cw.WriteString(string(v)); err != nil {
2595 return err
2596 }
2597
2598 }
2599
2600 // t.Multiple (bool) (bool)
2601 if t.Multiple != nil {
2602
2603 if len("multiple") > 1000000 {
2604 return xerrors.Errorf("Value in field \"multiple\" was too long")
2605 }
2606
2607 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("multiple"))); err != nil {
2608 return err
2609 }
2610 if _, err := cw.WriteString(string("multiple")); err != nil {
2611 return err
2612 }
2613
2614 if t.Multiple == nil {
2615 if _, err := cw.Write(cbg.CborNull); err != nil {
2616 return err
2617 }
2618 } else {
2619 if err := cbg.WriteBool(w, *t.Multiple); err != nil {
2620 return err
2621 }
2622 }
2623 }
2624
2625 // t.CreatedAt (string) (string)
2626 if len("createdAt") > 1000000 {
2627 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2628 }
2629
2630 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2631 return err
2632 }
2633 if _, err := cw.WriteString(string("createdAt")); err != nil {
2634 return err
2635 }
2636
2637 if len(t.CreatedAt) > 1000000 {
2638 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2639 }
2640
2641 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2642 return err
2643 }
2644 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2645 return err
2646 }
2647
2648 // t.ValueType (tangled.LabelDefinition_ValueType) (struct)
2649 if len("valueType") > 1000000 {
2650 return xerrors.Errorf("Value in field \"valueType\" was too long")
2651 }
2652
2653 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("valueType"))); err != nil {
2654 return err
2655 }
2656 if _, err := cw.WriteString(string("valueType")); err != nil {
2657 return err
2658 }
2659
2660 if err := t.ValueType.MarshalCBOR(cw); err != nil {
2661 return err
2662 }
2663 return nil
2664}
2665
2666func (t *LabelDefinition) UnmarshalCBOR(r io.Reader) (err error) {
2667 *t = LabelDefinition{}
2668
2669 cr := cbg.NewCborReader(r)
2670
2671 maj, extra, err := cr.ReadHeader()
2672 if err != nil {
2673 return err
2674 }
2675 defer func() {
2676 if err == io.EOF {
2677 err = io.ErrUnexpectedEOF
2678 }
2679 }()
2680
2681 if maj != cbg.MajMap {
2682 return fmt.Errorf("cbor input should be of type map")
2683 }
2684
2685 if extra > cbg.MaxLength {
2686 return fmt.Errorf("LabelDefinition: map struct too large (%d)", extra)
2687 }
2688
2689 n := extra
2690
2691 nameBuf := make([]byte, 9)
2692 for i := uint64(0); i < n; i++ {
2693 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2694 if err != nil {
2695 return err
2696 }
2697
2698 if !ok {
2699 // Field doesn't exist on this type, so ignore it
2700 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2701 return err
2702 }
2703 continue
2704 }
2705
2706 switch string(nameBuf[:nameLen]) {
2707 // t.Name (string) (string)
2708 case "name":
2709
2710 {
2711 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2712 if err != nil {
2713 return err
2714 }
2715
2716 t.Name = string(sval)
2717 }
2718 // t.LexiconTypeID (string) (string)
2719 case "$type":
2720
2721 {
2722 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2723 if err != nil {
2724 return err
2725 }
2726
2727 t.LexiconTypeID = string(sval)
2728 }
2729 // t.Color (string) (string)
2730 case "color":
2731
2732 {
2733 b, err := cr.ReadByte()
2734 if err != nil {
2735 return err
2736 }
2737 if b != cbg.CborNull[0] {
2738 if err := cr.UnreadByte(); err != nil {
2739 return err
2740 }
2741
2742 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2743 if err != nil {
2744 return err
2745 }
2746
2747 t.Color = (*string)(&sval)
2748 }
2749 }
2750 // t.Scope ([]string) (slice)
2751 case "scope":
2752
2753 maj, extra, err = cr.ReadHeader()
2754 if err != nil {
2755 return err
2756 }
2757
2758 if extra > 8192 {
2759 return fmt.Errorf("t.Scope: array too large (%d)", extra)
2760 }
2761
2762 if maj != cbg.MajArray {
2763 return fmt.Errorf("expected cbor array")
2764 }
2765
2766 if extra > 0 {
2767 t.Scope = make([]string, extra)
2768 }
2769
2770 for i := 0; i < int(extra); i++ {
2771 {
2772 var maj byte
2773 var extra uint64
2774 var err error
2775 _ = maj
2776 _ = extra
2777 _ = err
2778
2779 {
2780 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2781 if err != nil {
2782 return err
2783 }
2784
2785 t.Scope[i] = string(sval)
2786 }
2787
2788 }
2789 }
2790 // t.Multiple (bool) (bool)
2791 case "multiple":
2792
2793 {
2794 b, err := cr.ReadByte()
2795 if err != nil {
2796 return err
2797 }
2798 if b != cbg.CborNull[0] {
2799 if err := cr.UnreadByte(); err != nil {
2800 return err
2801 }
2802
2803 maj, extra, err = cr.ReadHeader()
2804 if err != nil {
2805 return err
2806 }
2807 if maj != cbg.MajOther {
2808 return fmt.Errorf("booleans must be major type 7")
2809 }
2810
2811 var val bool
2812 switch extra {
2813 case 20:
2814 val = false
2815 case 21:
2816 val = true
2817 default:
2818 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
2819 }
2820 t.Multiple = &val
2821 }
2822 }
2823 // t.CreatedAt (string) (string)
2824 case "createdAt":
2825
2826 {
2827 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2828 if err != nil {
2829 return err
2830 }
2831
2832 t.CreatedAt = string(sval)
2833 }
2834 // t.ValueType (tangled.LabelDefinition_ValueType) (struct)
2835 case "valueType":
2836
2837 {
2838
2839 b, err := cr.ReadByte()
2840 if err != nil {
2841 return err
2842 }
2843 if b != cbg.CborNull[0] {
2844 if err := cr.UnreadByte(); err != nil {
2845 return err
2846 }
2847 t.ValueType = new(LabelDefinition_ValueType)
2848 if err := t.ValueType.UnmarshalCBOR(cr); err != nil {
2849 return xerrors.Errorf("unmarshaling t.ValueType pointer: %w", err)
2850 }
2851 }
2852
2853 }
2854
2855 default:
2856 // Field doesn't exist on this type, so ignore it
2857 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2858 return err
2859 }
2860 }
2861 }
2862
2863 return nil
2864}
2865func (t *LabelDefinition_ValueType) MarshalCBOR(w io.Writer) error {
2866 if t == nil {
2867 _, err := w.Write(cbg.CborNull)
2868 return err
2869 }
2870
2871 cw := cbg.NewCborWriter(w)
2872 fieldCount := 3
2873
2874 if t.Enum == nil {
2875 fieldCount--
2876 }
2877
2878 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2879 return err
2880 }
2881
2882 // t.Enum ([]string) (slice)
2883 if t.Enum != nil {
2884
2885 if len("enum") > 1000000 {
2886 return xerrors.Errorf("Value in field \"enum\" was too long")
2887 }
2888
2889 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("enum"))); err != nil {
2890 return err
2891 }
2892 if _, err := cw.WriteString(string("enum")); err != nil {
2893 return err
2894 }
2895
2896 if len(t.Enum) > 8192 {
2897 return xerrors.Errorf("Slice value in field t.Enum was too long")
2898 }
2899
2900 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Enum))); err != nil {
2901 return err
2902 }
2903 for _, v := range t.Enum {
2904 if len(v) > 1000000 {
2905 return xerrors.Errorf("Value in field v was too long")
2906 }
2907
2908 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
2909 return err
2910 }
2911 if _, err := cw.WriteString(string(v)); err != nil {
2912 return err
2913 }
2914
2915 }
2916 }
2917
2918 // t.Type (string) (string)
2919 if len("type") > 1000000 {
2920 return xerrors.Errorf("Value in field \"type\" was too long")
2921 }
2922
2923 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("type"))); err != nil {
2924 return err
2925 }
2926 if _, err := cw.WriteString(string("type")); err != nil {
2927 return err
2928 }
2929
2930 if len(t.Type) > 1000000 {
2931 return xerrors.Errorf("Value in field t.Type was too long")
2932 }
2933
2934 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Type))); err != nil {
2935 return err
2936 }
2937 if _, err := cw.WriteString(string(t.Type)); err != nil {
2938 return err
2939 }
2940
2941 // t.Format (string) (string)
2942 if len("format") > 1000000 {
2943 return xerrors.Errorf("Value in field \"format\" was too long")
2944 }
2945
2946 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("format"))); err != nil {
2947 return err
2948 }
2949 if _, err := cw.WriteString(string("format")); err != nil {
2950 return err
2951 }
2952
2953 if len(t.Format) > 1000000 {
2954 return xerrors.Errorf("Value in field t.Format was too long")
2955 }
2956
2957 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Format))); err != nil {
2958 return err
2959 }
2960 if _, err := cw.WriteString(string(t.Format)); err != nil {
2961 return err
2962 }
2963 return nil
2964}
2965
2966func (t *LabelDefinition_ValueType) UnmarshalCBOR(r io.Reader) (err error) {
2967 *t = LabelDefinition_ValueType{}
2968
2969 cr := cbg.NewCborReader(r)
2970
2971 maj, extra, err := cr.ReadHeader()
2972 if err != nil {
2973 return err
2974 }
2975 defer func() {
2976 if err == io.EOF {
2977 err = io.ErrUnexpectedEOF
2978 }
2979 }()
2980
2981 if maj != cbg.MajMap {
2982 return fmt.Errorf("cbor input should be of type map")
2983 }
2984
2985 if extra > cbg.MaxLength {
2986 return fmt.Errorf("LabelDefinition_ValueType: map struct too large (%d)", extra)
2987 }
2988
2989 n := extra
2990
2991 nameBuf := make([]byte, 6)
2992 for i := uint64(0); i < n; i++ {
2993 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2994 if err != nil {
2995 return err
2996 }
2997
2998 if !ok {
2999 // Field doesn't exist on this type, so ignore it
3000 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3001 return err
3002 }
3003 continue
3004 }
3005
3006 switch string(nameBuf[:nameLen]) {
3007 // t.Enum ([]string) (slice)
3008 case "enum":
3009
3010 maj, extra, err = cr.ReadHeader()
3011 if err != nil {
3012 return err
3013 }
3014
3015 if extra > 8192 {
3016 return fmt.Errorf("t.Enum: array too large (%d)", extra)
3017 }
3018
3019 if maj != cbg.MajArray {
3020 return fmt.Errorf("expected cbor array")
3021 }
3022
3023 if extra > 0 {
3024 t.Enum = make([]string, extra)
3025 }
3026
3027 for i := 0; i < int(extra); i++ {
3028 {
3029 var maj byte
3030 var extra uint64
3031 var err error
3032 _ = maj
3033 _ = extra
3034 _ = err
3035
3036 {
3037 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3038 if err != nil {
3039 return err
3040 }
3041
3042 t.Enum[i] = string(sval)
3043 }
3044
3045 }
3046 }
3047 // t.Type (string) (string)
3048 case "type":
3049
3050 {
3051 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3052 if err != nil {
3053 return err
3054 }
3055
3056 t.Type = string(sval)
3057 }
3058 // t.Format (string) (string)
3059 case "format":
3060
3061 {
3062 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3063 if err != nil {
3064 return err
3065 }
3066
3067 t.Format = string(sval)
3068 }
3069
3070 default:
3071 // Field doesn't exist on this type, so ignore it
3072 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3073 return err
3074 }
3075 }
3076 }
3077
3078 return nil
3079}
3080func (t *Pipeline) MarshalCBOR(w io.Writer) error {
3081 if t == nil {
3082 _, err := w.Write(cbg.CborNull)
3083 return err
3084 }
3085
3086 cw := cbg.NewCborWriter(w)
3087
3088 if _, err := cw.Write([]byte{163}); err != nil {
3089 return err
3090 }
3091
3092 // t.LexiconTypeID (string) (string)
3093 if len("$type") > 1000000 {
3094 return xerrors.Errorf("Value in field \"$type\" was too long")
3095 }
3096
3097 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3098 return err
3099 }
3100 if _, err := cw.WriteString(string("$type")); err != nil {
3101 return err
3102 }
3103
3104 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil {
3105 return err
3106 }
3107 if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil {
3108 return err
3109 }
3110
3111 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
3112 if len("workflows") > 1000000 {
3113 return xerrors.Errorf("Value in field \"workflows\" was too long")
3114 }
3115
3116 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil {
3117 return err
3118 }
3119 if _, err := cw.WriteString(string("workflows")); err != nil {
3120 return err
3121 }
3122
3123 if len(t.Workflows) > 8192 {
3124 return xerrors.Errorf("Slice value in field t.Workflows was too long")
3125 }
3126
3127 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil {
3128 return err
3129 }
3130 for _, v := range t.Workflows {
3131 if err := v.MarshalCBOR(cw); err != nil {
3132 return err
3133 }
3134
3135 }
3136
3137 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
3138 if len("triggerMetadata") > 1000000 {
3139 return xerrors.Errorf("Value in field \"triggerMetadata\" was too long")
3140 }
3141
3142 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil {
3143 return err
3144 }
3145 if _, err := cw.WriteString(string("triggerMetadata")); err != nil {
3146 return err
3147 }
3148
3149 if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil {
3150 return err
3151 }
3152 return nil
3153}
3154
3155func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) {
3156 *t = Pipeline{}
3157
3158 cr := cbg.NewCborReader(r)
3159
3160 maj, extra, err := cr.ReadHeader()
3161 if err != nil {
3162 return err
3163 }
3164 defer func() {
3165 if err == io.EOF {
3166 err = io.ErrUnexpectedEOF
3167 }
3168 }()
3169
3170 if maj != cbg.MajMap {
3171 return fmt.Errorf("cbor input should be of type map")
3172 }
3173
3174 if extra > cbg.MaxLength {
3175 return fmt.Errorf("Pipeline: map struct too large (%d)", extra)
3176 }
3177
3178 n := extra
3179
3180 nameBuf := make([]byte, 15)
3181 for i := uint64(0); i < n; i++ {
3182 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3183 if err != nil {
3184 return err
3185 }
3186
3187 if !ok {
3188 // Field doesn't exist on this type, so ignore it
3189 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3190 return err
3191 }
3192 continue
3193 }
3194
3195 switch string(nameBuf[:nameLen]) {
3196 // t.LexiconTypeID (string) (string)
3197 case "$type":
3198
3199 {
3200 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3201 if err != nil {
3202 return err
3203 }
3204
3205 t.LexiconTypeID = string(sval)
3206 }
3207 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
3208 case "workflows":
3209
3210 maj, extra, err = cr.ReadHeader()
3211 if err != nil {
3212 return err
3213 }
3214
3215 if extra > 8192 {
3216 return fmt.Errorf("t.Workflows: array too large (%d)", extra)
3217 }
3218
3219 if maj != cbg.MajArray {
3220 return fmt.Errorf("expected cbor array")
3221 }
3222
3223 if extra > 0 {
3224 t.Workflows = make([]*Pipeline_Workflow, extra)
3225 }
3226
3227 for i := 0; i < int(extra); i++ {
3228 {
3229 var maj byte
3230 var extra uint64
3231 var err error
3232 _ = maj
3233 _ = extra
3234 _ = err
3235
3236 {
3237
3238 b, err := cr.ReadByte()
3239 if err != nil {
3240 return err
3241 }
3242 if b != cbg.CborNull[0] {
3243 if err := cr.UnreadByte(); err != nil {
3244 return err
3245 }
3246 t.Workflows[i] = new(Pipeline_Workflow)
3247 if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil {
3248 return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err)
3249 }
3250 }
3251
3252 }
3253
3254 }
3255 }
3256 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
3257 case "triggerMetadata":
3258
3259 {
3260
3261 b, err := cr.ReadByte()
3262 if err != nil {
3263 return err
3264 }
3265 if b != cbg.CborNull[0] {
3266 if err := cr.UnreadByte(); err != nil {
3267 return err
3268 }
3269 t.TriggerMetadata = new(Pipeline_TriggerMetadata)
3270 if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil {
3271 return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err)
3272 }
3273 }
3274
3275 }
3276
3277 default:
3278 // Field doesn't exist on this type, so ignore it
3279 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3280 return err
3281 }
3282 }
3283 }
3284
3285 return nil
3286}
3287func (t *Pipeline_CloneOpts) MarshalCBOR(w io.Writer) error {
3288 if t == nil {
3289 _, err := w.Write(cbg.CborNull)
3290 return err
3291 }
3292
3293 cw := cbg.NewCborWriter(w)
3294
3295 if _, err := cw.Write([]byte{163}); err != nil {
3296 return err
3297 }
3298
3299 // t.Skip (bool) (bool)
3300 if len("skip") > 1000000 {
3301 return xerrors.Errorf("Value in field \"skip\" was too long")
3302 }
3303
3304 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("skip"))); err != nil {
3305 return err
3306 }
3307 if _, err := cw.WriteString(string("skip")); err != nil {
3308 return err
3309 }
3310
3311 if err := cbg.WriteBool(w, t.Skip); err != nil {
3312 return err
3313 }
3314
3315 // t.Depth (int64) (int64)
3316 if len("depth") > 1000000 {
3317 return xerrors.Errorf("Value in field \"depth\" was too long")
3318 }
3319
3320 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("depth"))); err != nil {
3321 return err
3322 }
3323 if _, err := cw.WriteString(string("depth")); err != nil {
3324 return err
3325 }
3326
3327 if t.Depth >= 0 {
3328 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Depth)); err != nil {
3329 return err
3330 }
3331 } else {
3332 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Depth-1)); err != nil {
3333 return err
3334 }
3335 }
3336
3337 // t.Submodules (bool) (bool)
3338 if len("submodules") > 1000000 {
3339 return xerrors.Errorf("Value in field \"submodules\" was too long")
3340 }
3341
3342 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("submodules"))); err != nil {
3343 return err
3344 }
3345 if _, err := cw.WriteString(string("submodules")); err != nil {
3346 return err
3347 }
3348
3349 if err := cbg.WriteBool(w, t.Submodules); err != nil {
3350 return err
3351 }
3352 return nil
3353}
3354
3355func (t *Pipeline_CloneOpts) UnmarshalCBOR(r io.Reader) (err error) {
3356 *t = Pipeline_CloneOpts{}
3357
3358 cr := cbg.NewCborReader(r)
3359
3360 maj, extra, err := cr.ReadHeader()
3361 if err != nil {
3362 return err
3363 }
3364 defer func() {
3365 if err == io.EOF {
3366 err = io.ErrUnexpectedEOF
3367 }
3368 }()
3369
3370 if maj != cbg.MajMap {
3371 return fmt.Errorf("cbor input should be of type map")
3372 }
3373
3374 if extra > cbg.MaxLength {
3375 return fmt.Errorf("Pipeline_CloneOpts: map struct too large (%d)", extra)
3376 }
3377
3378 n := extra
3379
3380 nameBuf := make([]byte, 10)
3381 for i := uint64(0); i < n; i++ {
3382 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3383 if err != nil {
3384 return err
3385 }
3386
3387 if !ok {
3388 // Field doesn't exist on this type, so ignore it
3389 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3390 return err
3391 }
3392 continue
3393 }
3394
3395 switch string(nameBuf[:nameLen]) {
3396 // t.Skip (bool) (bool)
3397 case "skip":
3398
3399 maj, extra, err = cr.ReadHeader()
3400 if err != nil {
3401 return err
3402 }
3403 if maj != cbg.MajOther {
3404 return fmt.Errorf("booleans must be major type 7")
3405 }
3406 switch extra {
3407 case 20:
3408 t.Skip = false
3409 case 21:
3410 t.Skip = true
3411 default:
3412 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
3413 }
3414 // t.Depth (int64) (int64)
3415 case "depth":
3416 {
3417 maj, extra, err := cr.ReadHeader()
3418 if err != nil {
3419 return err
3420 }
3421 var extraI int64
3422 switch maj {
3423 case cbg.MajUnsignedInt:
3424 extraI = int64(extra)
3425 if extraI < 0 {
3426 return fmt.Errorf("int64 positive overflow")
3427 }
3428 case cbg.MajNegativeInt:
3429 extraI = int64(extra)
3430 if extraI < 0 {
3431 return fmt.Errorf("int64 negative overflow")
3432 }
3433 extraI = -1 - extraI
3434 default:
3435 return fmt.Errorf("wrong type for int64 field: %d", maj)
3436 }
3437
3438 t.Depth = int64(extraI)
3439 }
3440 // t.Submodules (bool) (bool)
3441 case "submodules":
3442
3443 maj, extra, err = cr.ReadHeader()
3444 if err != nil {
3445 return err
3446 }
3447 if maj != cbg.MajOther {
3448 return fmt.Errorf("booleans must be major type 7")
3449 }
3450 switch extra {
3451 case 20:
3452 t.Submodules = false
3453 case 21:
3454 t.Submodules = true
3455 default:
3456 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
3457 }
3458
3459 default:
3460 // Field doesn't exist on this type, so ignore it
3461 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3462 return err
3463 }
3464 }
3465 }
3466
3467 return nil
3468}
3469func (t *Pipeline_ManualTriggerData) MarshalCBOR(w io.Writer) error {
3470 if t == nil {
3471 _, err := w.Write(cbg.CborNull)
3472 return err
3473 }
3474
3475 cw := cbg.NewCborWriter(w)
3476 fieldCount := 1
3477
3478 if t.Inputs == nil {
3479 fieldCount--
3480 }
3481
3482 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3483 return err
3484 }
3485
3486 // t.Inputs ([]*tangled.Pipeline_Pair) (slice)
3487 if t.Inputs != nil {
3488
3489 if len("inputs") > 1000000 {
3490 return xerrors.Errorf("Value in field \"inputs\" was too long")
3491 }
3492
3493 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
3494 return err
3495 }
3496 if _, err := cw.WriteString(string("inputs")); err != nil {
3497 return err
3498 }
3499
3500 if len(t.Inputs) > 8192 {
3501 return xerrors.Errorf("Slice value in field t.Inputs was too long")
3502 }
3503
3504 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
3505 return err
3506 }
3507 for _, v := range t.Inputs {
3508 if err := v.MarshalCBOR(cw); err != nil {
3509 return err
3510 }
3511
3512 }
3513 }
3514 return nil
3515}
3516
3517func (t *Pipeline_ManualTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
3518 *t = Pipeline_ManualTriggerData{}
3519
3520 cr := cbg.NewCborReader(r)
3521
3522 maj, extra, err := cr.ReadHeader()
3523 if err != nil {
3524 return err
3525 }
3526 defer func() {
3527 if err == io.EOF {
3528 err = io.ErrUnexpectedEOF
3529 }
3530 }()
3531
3532 if maj != cbg.MajMap {
3533 return fmt.Errorf("cbor input should be of type map")
3534 }
3535
3536 if extra > cbg.MaxLength {
3537 return fmt.Errorf("Pipeline_ManualTriggerData: map struct too large (%d)", extra)
3538 }
3539
3540 n := extra
3541
3542 nameBuf := make([]byte, 6)
3543 for i := uint64(0); i < n; i++ {
3544 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3545 if err != nil {
3546 return err
3547 }
3548
3549 if !ok {
3550 // Field doesn't exist on this type, so ignore it
3551 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3552 return err
3553 }
3554 continue
3555 }
3556
3557 switch string(nameBuf[:nameLen]) {
3558 // t.Inputs ([]*tangled.Pipeline_Pair) (slice)
3559 case "inputs":
3560
3561 maj, extra, err = cr.ReadHeader()
3562 if err != nil {
3563 return err
3564 }
3565
3566 if extra > 8192 {
3567 return fmt.Errorf("t.Inputs: array too large (%d)", extra)
3568 }
3569
3570 if maj != cbg.MajArray {
3571 return fmt.Errorf("expected cbor array")
3572 }
3573
3574 if extra > 0 {
3575 t.Inputs = make([]*Pipeline_Pair, extra)
3576 }
3577
3578 for i := 0; i < int(extra); i++ {
3579 {
3580 var maj byte
3581 var extra uint64
3582 var err error
3583 _ = maj
3584 _ = extra
3585 _ = err
3586
3587 {
3588
3589 b, err := cr.ReadByte()
3590 if err != nil {
3591 return err
3592 }
3593 if b != cbg.CborNull[0] {
3594 if err := cr.UnreadByte(); err != nil {
3595 return err
3596 }
3597 t.Inputs[i] = new(Pipeline_Pair)
3598 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
3599 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
3600 }
3601 }
3602
3603 }
3604
3605 }
3606 }
3607
3608 default:
3609 // Field doesn't exist on this type, so ignore it
3610 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3611 return err
3612 }
3613 }
3614 }
3615
3616 return nil
3617}
3618func (t *Pipeline_Pair) MarshalCBOR(w io.Writer) error {
3619 if t == nil {
3620 _, err := w.Write(cbg.CborNull)
3621 return err
3622 }
3623
3624 cw := cbg.NewCborWriter(w)
3625
3626 if _, err := cw.Write([]byte{162}); err != nil {
3627 return err
3628 }
3629
3630 // t.Key (string) (string)
3631 if len("key") > 1000000 {
3632 return xerrors.Errorf("Value in field \"key\" was too long")
3633 }
3634
3635 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
3636 return err
3637 }
3638 if _, err := cw.WriteString(string("key")); err != nil {
3639 return err
3640 }
3641
3642 if len(t.Key) > 1000000 {
3643 return xerrors.Errorf("Value in field t.Key was too long")
3644 }
3645
3646 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
3647 return err
3648 }
3649 if _, err := cw.WriteString(string(t.Key)); err != nil {
3650 return err
3651 }
3652
3653 // t.Value (string) (string)
3654 if len("value") > 1000000 {
3655 return xerrors.Errorf("Value in field \"value\" was too long")
3656 }
3657
3658 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
3659 return err
3660 }
3661 if _, err := cw.WriteString(string("value")); err != nil {
3662 return err
3663 }
3664
3665 if len(t.Value) > 1000000 {
3666 return xerrors.Errorf("Value in field t.Value was too long")
3667 }
3668
3669 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
3670 return err
3671 }
3672 if _, err := cw.WriteString(string(t.Value)); err != nil {
3673 return err
3674 }
3675 return nil
3676}
3677
3678func (t *Pipeline_Pair) UnmarshalCBOR(r io.Reader) (err error) {
3679 *t = Pipeline_Pair{}
3680
3681 cr := cbg.NewCborReader(r)
3682
3683 maj, extra, err := cr.ReadHeader()
3684 if err != nil {
3685 return err
3686 }
3687 defer func() {
3688 if err == io.EOF {
3689 err = io.ErrUnexpectedEOF
3690 }
3691 }()
3692
3693 if maj != cbg.MajMap {
3694 return fmt.Errorf("cbor input should be of type map")
3695 }
3696
3697 if extra > cbg.MaxLength {
3698 return fmt.Errorf("Pipeline_Pair: map struct too large (%d)", extra)
3699 }
3700
3701 n := extra
3702
3703 nameBuf := make([]byte, 5)
3704 for i := uint64(0); i < n; i++ {
3705 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3706 if err != nil {
3707 return err
3708 }
3709
3710 if !ok {
3711 // Field doesn't exist on this type, so ignore it
3712 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3713 return err
3714 }
3715 continue
3716 }
3717
3718 switch string(nameBuf[:nameLen]) {
3719 // t.Key (string) (string)
3720 case "key":
3721
3722 {
3723 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3724 if err != nil {
3725 return err
3726 }
3727
3728 t.Key = string(sval)
3729 }
3730 // t.Value (string) (string)
3731 case "value":
3732
3733 {
3734 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3735 if err != nil {
3736 return err
3737 }
3738
3739 t.Value = string(sval)
3740 }
3741
3742 default:
3743 // Field doesn't exist on this type, so ignore it
3744 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3745 return err
3746 }
3747 }
3748 }
3749
3750 return nil
3751}
3752func (t *Pipeline_PullRequestTriggerData) MarshalCBOR(w io.Writer) error {
3753 if t == nil {
3754 _, err := w.Write(cbg.CborNull)
3755 return err
3756 }
3757
3758 cw := cbg.NewCborWriter(w)
3759
3760 if _, err := cw.Write([]byte{164}); err != nil {
3761 return err
3762 }
3763
3764 // t.Action (string) (string)
3765 if len("action") > 1000000 {
3766 return xerrors.Errorf("Value in field \"action\" was too long")
3767 }
3768
3769 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("action"))); err != nil {
3770 return err
3771 }
3772 if _, err := cw.WriteString(string("action")); err != nil {
3773 return err
3774 }
3775
3776 if len(t.Action) > 1000000 {
3777 return xerrors.Errorf("Value in field t.Action was too long")
3778 }
3779
3780 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Action))); err != nil {
3781 return err
3782 }
3783 if _, err := cw.WriteString(string(t.Action)); err != nil {
3784 return err
3785 }
3786
3787 // t.SourceSha (string) (string)
3788 if len("sourceSha") > 1000000 {
3789 return xerrors.Errorf("Value in field \"sourceSha\" was too long")
3790 }
3791
3792 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceSha"))); err != nil {
3793 return err
3794 }
3795 if _, err := cw.WriteString(string("sourceSha")); err != nil {
3796 return err
3797 }
3798
3799 if len(t.SourceSha) > 1000000 {
3800 return xerrors.Errorf("Value in field t.SourceSha was too long")
3801 }
3802
3803 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceSha))); err != nil {
3804 return err
3805 }
3806 if _, err := cw.WriteString(string(t.SourceSha)); err != nil {
3807 return err
3808 }
3809
3810 // t.SourceBranch (string) (string)
3811 if len("sourceBranch") > 1000000 {
3812 return xerrors.Errorf("Value in field \"sourceBranch\" was too long")
3813 }
3814
3815 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceBranch"))); err != nil {
3816 return err
3817 }
3818 if _, err := cw.WriteString(string("sourceBranch")); err != nil {
3819 return err
3820 }
3821
3822 if len(t.SourceBranch) > 1000000 {
3823 return xerrors.Errorf("Value in field t.SourceBranch was too long")
3824 }
3825
3826 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceBranch))); err != nil {
3827 return err
3828 }
3829 if _, err := cw.WriteString(string(t.SourceBranch)); err != nil {
3830 return err
3831 }
3832
3833 // t.TargetBranch (string) (string)
3834 if len("targetBranch") > 1000000 {
3835 return xerrors.Errorf("Value in field \"targetBranch\" was too long")
3836 }
3837
3838 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil {
3839 return err
3840 }
3841 if _, err := cw.WriteString(string("targetBranch")); err != nil {
3842 return err
3843 }
3844
3845 if len(t.TargetBranch) > 1000000 {
3846 return xerrors.Errorf("Value in field t.TargetBranch was too long")
3847 }
3848
3849 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil {
3850 return err
3851 }
3852 if _, err := cw.WriteString(string(t.TargetBranch)); err != nil {
3853 return err
3854 }
3855 return nil
3856}
3857
3858func (t *Pipeline_PullRequestTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
3859 *t = Pipeline_PullRequestTriggerData{}
3860
3861 cr := cbg.NewCborReader(r)
3862
3863 maj, extra, err := cr.ReadHeader()
3864 if err != nil {
3865 return err
3866 }
3867 defer func() {
3868 if err == io.EOF {
3869 err = io.ErrUnexpectedEOF
3870 }
3871 }()
3872
3873 if maj != cbg.MajMap {
3874 return fmt.Errorf("cbor input should be of type map")
3875 }
3876
3877 if extra > cbg.MaxLength {
3878 return fmt.Errorf("Pipeline_PullRequestTriggerData: map struct too large (%d)", extra)
3879 }
3880
3881 n := extra
3882
3883 nameBuf := make([]byte, 12)
3884 for i := uint64(0); i < n; i++ {
3885 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3886 if err != nil {
3887 return err
3888 }
3889
3890 if !ok {
3891 // Field doesn't exist on this type, so ignore it
3892 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3893 return err
3894 }
3895 continue
3896 }
3897
3898 switch string(nameBuf[:nameLen]) {
3899 // t.Action (string) (string)
3900 case "action":
3901
3902 {
3903 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3904 if err != nil {
3905 return err
3906 }
3907
3908 t.Action = string(sval)
3909 }
3910 // t.SourceSha (string) (string)
3911 case "sourceSha":
3912
3913 {
3914 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3915 if err != nil {
3916 return err
3917 }
3918
3919 t.SourceSha = string(sval)
3920 }
3921 // t.SourceBranch (string) (string)
3922 case "sourceBranch":
3923
3924 {
3925 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3926 if err != nil {
3927 return err
3928 }
3929
3930 t.SourceBranch = string(sval)
3931 }
3932 // t.TargetBranch (string) (string)
3933 case "targetBranch":
3934
3935 {
3936 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3937 if err != nil {
3938 return err
3939 }
3940
3941 t.TargetBranch = string(sval)
3942 }
3943
3944 default:
3945 // Field doesn't exist on this type, so ignore it
3946 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3947 return err
3948 }
3949 }
3950 }
3951
3952 return nil
3953}
3954func (t *Pipeline_PushTriggerData) MarshalCBOR(w io.Writer) error {
3955 if t == nil {
3956 _, err := w.Write(cbg.CborNull)
3957 return err
3958 }
3959
3960 cw := cbg.NewCborWriter(w)
3961
3962 if _, err := cw.Write([]byte{163}); err != nil {
3963 return err
3964 }
3965
3966 // t.Ref (string) (string)
3967 if len("ref") > 1000000 {
3968 return xerrors.Errorf("Value in field \"ref\" was too long")
3969 }
3970
3971 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
3972 return err
3973 }
3974 if _, err := cw.WriteString(string("ref")); err != nil {
3975 return err
3976 }
3977
3978 if len(t.Ref) > 1000000 {
3979 return xerrors.Errorf("Value in field t.Ref was too long")
3980 }
3981
3982 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
3983 return err
3984 }
3985 if _, err := cw.WriteString(string(t.Ref)); err != nil {
3986 return err
3987 }
3988
3989 // t.NewSha (string) (string)
3990 if len("newSha") > 1000000 {
3991 return xerrors.Errorf("Value in field \"newSha\" was too long")
3992 }
3993
3994 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
3995 return err
3996 }
3997 if _, err := cw.WriteString(string("newSha")); err != nil {
3998 return err
3999 }
4000
4001 if len(t.NewSha) > 1000000 {
4002 return xerrors.Errorf("Value in field t.NewSha was too long")
4003 }
4004
4005 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
4006 return err
4007 }
4008 if _, err := cw.WriteString(string(t.NewSha)); err != nil {
4009 return err
4010 }
4011
4012 // t.OldSha (string) (string)
4013 if len("oldSha") > 1000000 {
4014 return xerrors.Errorf("Value in field \"oldSha\" was too long")
4015 }
4016
4017 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
4018 return err
4019 }
4020 if _, err := cw.WriteString(string("oldSha")); err != nil {
4021 return err
4022 }
4023
4024 if len(t.OldSha) > 1000000 {
4025 return xerrors.Errorf("Value in field t.OldSha was too long")
4026 }
4027
4028 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
4029 return err
4030 }
4031 if _, err := cw.WriteString(string(t.OldSha)); err != nil {
4032 return err
4033 }
4034 return nil
4035}
4036
4037func (t *Pipeline_PushTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
4038 *t = Pipeline_PushTriggerData{}
4039
4040 cr := cbg.NewCborReader(r)
4041
4042 maj, extra, err := cr.ReadHeader()
4043 if err != nil {
4044 return err
4045 }
4046 defer func() {
4047 if err == io.EOF {
4048 err = io.ErrUnexpectedEOF
4049 }
4050 }()
4051
4052 if maj != cbg.MajMap {
4053 return fmt.Errorf("cbor input should be of type map")
4054 }
4055
4056 if extra > cbg.MaxLength {
4057 return fmt.Errorf("Pipeline_PushTriggerData: map struct too large (%d)", extra)
4058 }
4059
4060 n := extra
4061
4062 nameBuf := make([]byte, 6)
4063 for i := uint64(0); i < n; i++ {
4064 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4065 if err != nil {
4066 return err
4067 }
4068
4069 if !ok {
4070 // Field doesn't exist on this type, so ignore it
4071 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4072 return err
4073 }
4074 continue
4075 }
4076
4077 switch string(nameBuf[:nameLen]) {
4078 // t.Ref (string) (string)
4079 case "ref":
4080
4081 {
4082 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4083 if err != nil {
4084 return err
4085 }
4086
4087 t.Ref = string(sval)
4088 }
4089 // t.NewSha (string) (string)
4090 case "newSha":
4091
4092 {
4093 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4094 if err != nil {
4095 return err
4096 }
4097
4098 t.NewSha = string(sval)
4099 }
4100 // t.OldSha (string) (string)
4101 case "oldSha":
4102
4103 {
4104 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4105 if err != nil {
4106 return err
4107 }
4108
4109 t.OldSha = string(sval)
4110 }
4111
4112 default:
4113 // Field doesn't exist on this type, so ignore it
4114 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4115 return err
4116 }
4117 }
4118 }
4119
4120 return nil
4121}
4122func (t *PipelineStatus) MarshalCBOR(w io.Writer) error {
4123 if t == nil {
4124 _, err := w.Write(cbg.CborNull)
4125 return err
4126 }
4127
4128 cw := cbg.NewCborWriter(w)
4129 fieldCount := 7
4130
4131 if t.Error == nil {
4132 fieldCount--
4133 }
4134
4135 if t.ExitCode == nil {
4136 fieldCount--
4137 }
4138
4139 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4140 return err
4141 }
4142
4143 // t.LexiconTypeID (string) (string)
4144 if len("$type") > 1000000 {
4145 return xerrors.Errorf("Value in field \"$type\" was too long")
4146 }
4147
4148 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
4149 return err
4150 }
4151 if _, err := cw.WriteString(string("$type")); err != nil {
4152 return err
4153 }
4154
4155 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline.status"))); err != nil {
4156 return err
4157 }
4158 if _, err := cw.WriteString(string("sh.tangled.pipeline.status")); err != nil {
4159 return err
4160 }
4161
4162 // t.Error (string) (string)
4163 if t.Error != nil {
4164
4165 if len("error") > 1000000 {
4166 return xerrors.Errorf("Value in field \"error\" was too long")
4167 }
4168
4169 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("error"))); err != nil {
4170 return err
4171 }
4172 if _, err := cw.WriteString(string("error")); err != nil {
4173 return err
4174 }
4175
4176 if t.Error == nil {
4177 if _, err := cw.Write(cbg.CborNull); err != nil {
4178 return err
4179 }
4180 } else {
4181 if len(*t.Error) > 1000000 {
4182 return xerrors.Errorf("Value in field t.Error was too long")
4183 }
4184
4185 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Error))); err != nil {
4186 return err
4187 }
4188 if _, err := cw.WriteString(string(*t.Error)); err != nil {
4189 return err
4190 }
4191 }
4192 }
4193
4194 // t.Status (string) (string)
4195 if len("status") > 1000000 {
4196 return xerrors.Errorf("Value in field \"status\" was too long")
4197 }
4198
4199 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
4200 return err
4201 }
4202 if _, err := cw.WriteString(string("status")); err != nil {
4203 return err
4204 }
4205
4206 if len(t.Status) > 1000000 {
4207 return xerrors.Errorf("Value in field t.Status was too long")
4208 }
4209
4210 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
4211 return err
4212 }
4213 if _, err := cw.WriteString(string(t.Status)); err != nil {
4214 return err
4215 }
4216
4217 // t.ExitCode (int64) (int64)
4218 if t.ExitCode != nil {
4219
4220 if len("exitCode") > 1000000 {
4221 return xerrors.Errorf("Value in field \"exitCode\" was too long")
4222 }
4223
4224 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("exitCode"))); err != nil {
4225 return err
4226 }
4227 if _, err := cw.WriteString(string("exitCode")); err != nil {
4228 return err
4229 }
4230
4231 if t.ExitCode == nil {
4232 if _, err := cw.Write(cbg.CborNull); err != nil {
4233 return err
4234 }
4235 } else {
4236 if *t.ExitCode >= 0 {
4237 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.ExitCode)); err != nil {
4238 return err
4239 }
4240 } else {
4241 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.ExitCode-1)); err != nil {
4242 return err
4243 }
4244 }
4245 }
4246
4247 }
4248
4249 // t.Pipeline (string) (string)
4250 if len("pipeline") > 1000000 {
4251 return xerrors.Errorf("Value in field \"pipeline\" was too long")
4252 }
4253
4254 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pipeline"))); err != nil {
4255 return err
4256 }
4257 if _, err := cw.WriteString(string("pipeline")); err != nil {
4258 return err
4259 }
4260
4261 if len(t.Pipeline) > 1000000 {
4262 return xerrors.Errorf("Value in field t.Pipeline was too long")
4263 }
4264
4265 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pipeline))); err != nil {
4266 return err
4267 }
4268 if _, err := cw.WriteString(string(t.Pipeline)); err != nil {
4269 return err
4270 }
4271
4272 // t.Workflow (string) (string)
4273 if len("workflow") > 1000000 {
4274 return xerrors.Errorf("Value in field \"workflow\" was too long")
4275 }
4276
4277 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil {
4278 return err
4279 }
4280 if _, err := cw.WriteString(string("workflow")); err != nil {
4281 return err
4282 }
4283
4284 if len(t.Workflow) > 1000000 {
4285 return xerrors.Errorf("Value in field t.Workflow was too long")
4286 }
4287
4288 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil {
4289 return err
4290 }
4291 if _, err := cw.WriteString(string(t.Workflow)); err != nil {
4292 return err
4293 }
4294
4295 // t.CreatedAt (string) (string)
4296 if len("createdAt") > 1000000 {
4297 return xerrors.Errorf("Value in field \"createdAt\" was too long")
4298 }
4299
4300 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
4301 return err
4302 }
4303 if _, err := cw.WriteString(string("createdAt")); err != nil {
4304 return err
4305 }
4306
4307 if len(t.CreatedAt) > 1000000 {
4308 return xerrors.Errorf("Value in field t.CreatedAt was too long")
4309 }
4310
4311 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
4312 return err
4313 }
4314 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
4315 return err
4316 }
4317 return nil
4318}
4319
4320func (t *PipelineStatus) UnmarshalCBOR(r io.Reader) (err error) {
4321 *t = PipelineStatus{}
4322
4323 cr := cbg.NewCborReader(r)
4324
4325 maj, extra, err := cr.ReadHeader()
4326 if err != nil {
4327 return err
4328 }
4329 defer func() {
4330 if err == io.EOF {
4331 err = io.ErrUnexpectedEOF
4332 }
4333 }()
4334
4335 if maj != cbg.MajMap {
4336 return fmt.Errorf("cbor input should be of type map")
4337 }
4338
4339 if extra > cbg.MaxLength {
4340 return fmt.Errorf("PipelineStatus: map struct too large (%d)", extra)
4341 }
4342
4343 n := extra
4344
4345 nameBuf := make([]byte, 9)
4346 for i := uint64(0); i < n; i++ {
4347 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4348 if err != nil {
4349 return err
4350 }
4351
4352 if !ok {
4353 // Field doesn't exist on this type, so ignore it
4354 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4355 return err
4356 }
4357 continue
4358 }
4359
4360 switch string(nameBuf[:nameLen]) {
4361 // t.LexiconTypeID (string) (string)
4362 case "$type":
4363
4364 {
4365 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4366 if err != nil {
4367 return err
4368 }
4369
4370 t.LexiconTypeID = string(sval)
4371 }
4372 // t.Error (string) (string)
4373 case "error":
4374
4375 {
4376 b, err := cr.ReadByte()
4377 if err != nil {
4378 return err
4379 }
4380 if b != cbg.CborNull[0] {
4381 if err := cr.UnreadByte(); err != nil {
4382 return err
4383 }
4384
4385 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4386 if err != nil {
4387 return err
4388 }
4389
4390 t.Error = (*string)(&sval)
4391 }
4392 }
4393 // t.Status (string) (string)
4394 case "status":
4395
4396 {
4397 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4398 if err != nil {
4399 return err
4400 }
4401
4402 t.Status = string(sval)
4403 }
4404 // t.ExitCode (int64) (int64)
4405 case "exitCode":
4406 {
4407
4408 b, err := cr.ReadByte()
4409 if err != nil {
4410 return err
4411 }
4412 if b != cbg.CborNull[0] {
4413 if err := cr.UnreadByte(); err != nil {
4414 return err
4415 }
4416 maj, extra, err := cr.ReadHeader()
4417 if err != nil {
4418 return err
4419 }
4420 var extraI int64
4421 switch maj {
4422 case cbg.MajUnsignedInt:
4423 extraI = int64(extra)
4424 if extraI < 0 {
4425 return fmt.Errorf("int64 positive overflow")
4426 }
4427 case cbg.MajNegativeInt:
4428 extraI = int64(extra)
4429 if extraI < 0 {
4430 return fmt.Errorf("int64 negative overflow")
4431 }
4432 extraI = -1 - extraI
4433 default:
4434 return fmt.Errorf("wrong type for int64 field: %d", maj)
4435 }
4436
4437 t.ExitCode = (*int64)(&extraI)
4438 }
4439 }
4440 // t.Pipeline (string) (string)
4441 case "pipeline":
4442
4443 {
4444 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4445 if err != nil {
4446 return err
4447 }
4448
4449 t.Pipeline = string(sval)
4450 }
4451 // t.Workflow (string) (string)
4452 case "workflow":
4453
4454 {
4455 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4456 if err != nil {
4457 return err
4458 }
4459
4460 t.Workflow = string(sval)
4461 }
4462 // t.CreatedAt (string) (string)
4463 case "createdAt":
4464
4465 {
4466 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4467 if err != nil {
4468 return err
4469 }
4470
4471 t.CreatedAt = string(sval)
4472 }
4473
4474 default:
4475 // Field doesn't exist on this type, so ignore it
4476 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4477 return err
4478 }
4479 }
4480 }
4481
4482 return nil
4483}
4484func (t *Pipeline_TriggerMetadata) MarshalCBOR(w io.Writer) error {
4485 if t == nil {
4486 _, err := w.Write(cbg.CborNull)
4487 return err
4488 }
4489
4490 cw := cbg.NewCborWriter(w)
4491 fieldCount := 5
4492
4493 if t.Manual == nil {
4494 fieldCount--
4495 }
4496
4497 if t.PullRequest == nil {
4498 fieldCount--
4499 }
4500
4501 if t.Push == nil {
4502 fieldCount--
4503 }
4504
4505 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4506 return err
4507 }
4508
4509 // t.Kind (string) (string)
4510 if len("kind") > 1000000 {
4511 return xerrors.Errorf("Value in field \"kind\" was too long")
4512 }
4513
4514 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("kind"))); err != nil {
4515 return err
4516 }
4517 if _, err := cw.WriteString(string("kind")); err != nil {
4518 return err
4519 }
4520
4521 if len(t.Kind) > 1000000 {
4522 return xerrors.Errorf("Value in field t.Kind was too long")
4523 }
4524
4525 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Kind))); err != nil {
4526 return err
4527 }
4528 if _, err := cw.WriteString(string(t.Kind)); err != nil {
4529 return err
4530 }
4531
4532 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
4533 if t.Push != nil {
4534
4535 if len("push") > 1000000 {
4536 return xerrors.Errorf("Value in field \"push\" was too long")
4537 }
4538
4539 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("push"))); err != nil {
4540 return err
4541 }
4542 if _, err := cw.WriteString(string("push")); err != nil {
4543 return err
4544 }
4545
4546 if err := t.Push.MarshalCBOR(cw); err != nil {
4547 return err
4548 }
4549 }
4550
4551 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
4552 if len("repo") > 1000000 {
4553 return xerrors.Errorf("Value in field \"repo\" was too long")
4554 }
4555
4556 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
4557 return err
4558 }
4559 if _, err := cw.WriteString(string("repo")); err != nil {
4560 return err
4561 }
4562
4563 if err := t.Repo.MarshalCBOR(cw); err != nil {
4564 return err
4565 }
4566
4567 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
4568 if t.Manual != nil {
4569
4570 if len("manual") > 1000000 {
4571 return xerrors.Errorf("Value in field \"manual\" was too long")
4572 }
4573
4574 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("manual"))); err != nil {
4575 return err
4576 }
4577 if _, err := cw.WriteString(string("manual")); err != nil {
4578 return err
4579 }
4580
4581 if err := t.Manual.MarshalCBOR(cw); err != nil {
4582 return err
4583 }
4584 }
4585
4586 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
4587 if t.PullRequest != nil {
4588
4589 if len("pullRequest") > 1000000 {
4590 return xerrors.Errorf("Value in field \"pullRequest\" was too long")
4591 }
4592
4593 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullRequest"))); err != nil {
4594 return err
4595 }
4596 if _, err := cw.WriteString(string("pullRequest")); err != nil {
4597 return err
4598 }
4599
4600 if err := t.PullRequest.MarshalCBOR(cw); err != nil {
4601 return err
4602 }
4603 }
4604 return nil
4605}
4606
4607func (t *Pipeline_TriggerMetadata) UnmarshalCBOR(r io.Reader) (err error) {
4608 *t = Pipeline_TriggerMetadata{}
4609
4610 cr := cbg.NewCborReader(r)
4611
4612 maj, extra, err := cr.ReadHeader()
4613 if err != nil {
4614 return err
4615 }
4616 defer func() {
4617 if err == io.EOF {
4618 err = io.ErrUnexpectedEOF
4619 }
4620 }()
4621
4622 if maj != cbg.MajMap {
4623 return fmt.Errorf("cbor input should be of type map")
4624 }
4625
4626 if extra > cbg.MaxLength {
4627 return fmt.Errorf("Pipeline_TriggerMetadata: map struct too large (%d)", extra)
4628 }
4629
4630 n := extra
4631
4632 nameBuf := make([]byte, 11)
4633 for i := uint64(0); i < n; i++ {
4634 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4635 if err != nil {
4636 return err
4637 }
4638
4639 if !ok {
4640 // Field doesn't exist on this type, so ignore it
4641 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4642 return err
4643 }
4644 continue
4645 }
4646
4647 switch string(nameBuf[:nameLen]) {
4648 // t.Kind (string) (string)
4649 case "kind":
4650
4651 {
4652 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4653 if err != nil {
4654 return err
4655 }
4656
4657 t.Kind = string(sval)
4658 }
4659 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
4660 case "push":
4661
4662 {
4663
4664 b, err := cr.ReadByte()
4665 if err != nil {
4666 return err
4667 }
4668 if b != cbg.CborNull[0] {
4669 if err := cr.UnreadByte(); err != nil {
4670 return err
4671 }
4672 t.Push = new(Pipeline_PushTriggerData)
4673 if err := t.Push.UnmarshalCBOR(cr); err != nil {
4674 return xerrors.Errorf("unmarshaling t.Push pointer: %w", err)
4675 }
4676 }
4677
4678 }
4679 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
4680 case "repo":
4681
4682 {
4683
4684 b, err := cr.ReadByte()
4685 if err != nil {
4686 return err
4687 }
4688 if b != cbg.CborNull[0] {
4689 if err := cr.UnreadByte(); err != nil {
4690 return err
4691 }
4692 t.Repo = new(Pipeline_TriggerRepo)
4693 if err := t.Repo.UnmarshalCBOR(cr); err != nil {
4694 return xerrors.Errorf("unmarshaling t.Repo pointer: %w", err)
4695 }
4696 }
4697
4698 }
4699 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
4700 case "manual":
4701
4702 {
4703
4704 b, err := cr.ReadByte()
4705 if err != nil {
4706 return err
4707 }
4708 if b != cbg.CborNull[0] {
4709 if err := cr.UnreadByte(); err != nil {
4710 return err
4711 }
4712 t.Manual = new(Pipeline_ManualTriggerData)
4713 if err := t.Manual.UnmarshalCBOR(cr); err != nil {
4714 return xerrors.Errorf("unmarshaling t.Manual pointer: %w", err)
4715 }
4716 }
4717
4718 }
4719 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
4720 case "pullRequest":
4721
4722 {
4723
4724 b, err := cr.ReadByte()
4725 if err != nil {
4726 return err
4727 }
4728 if b != cbg.CborNull[0] {
4729 if err := cr.UnreadByte(); err != nil {
4730 return err
4731 }
4732 t.PullRequest = new(Pipeline_PullRequestTriggerData)
4733 if err := t.PullRequest.UnmarshalCBOR(cr); err != nil {
4734 return xerrors.Errorf("unmarshaling t.PullRequest pointer: %w", err)
4735 }
4736 }
4737
4738 }
4739
4740 default:
4741 // Field doesn't exist on this type, so ignore it
4742 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4743 return err
4744 }
4745 }
4746 }
4747
4748 return nil
4749}
4750func (t *Pipeline_TriggerRepo) MarshalCBOR(w io.Writer) error {
4751 if t == nil {
4752 _, err := w.Write(cbg.CborNull)
4753 return err
4754 }
4755
4756 cw := cbg.NewCborWriter(w)
4757
4758 if _, err := cw.Write([]byte{164}); err != nil {
4759 return err
4760 }
4761
4762 // t.Did (string) (string)
4763 if len("did") > 1000000 {
4764 return xerrors.Errorf("Value in field \"did\" was too long")
4765 }
4766
4767 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil {
4768 return err
4769 }
4770 if _, err := cw.WriteString(string("did")); err != nil {
4771 return err
4772 }
4773
4774 if len(t.Did) > 1000000 {
4775 return xerrors.Errorf("Value in field t.Did was too long")
4776 }
4777
4778 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil {
4779 return err
4780 }
4781 if _, err := cw.WriteString(string(t.Did)); err != nil {
4782 return err
4783 }
4784
4785 // t.Knot (string) (string)
4786 if len("knot") > 1000000 {
4787 return xerrors.Errorf("Value in field \"knot\" was too long")
4788 }
4789
4790 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
4791 return err
4792 }
4793 if _, err := cw.WriteString(string("knot")); err != nil {
4794 return err
4795 }
4796
4797 if len(t.Knot) > 1000000 {
4798 return xerrors.Errorf("Value in field t.Knot was too long")
4799 }
4800
4801 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
4802 return err
4803 }
4804 if _, err := cw.WriteString(string(t.Knot)); err != nil {
4805 return err
4806 }
4807
4808 // t.Repo (string) (string)
4809 if len("repo") > 1000000 {
4810 return xerrors.Errorf("Value in field \"repo\" was too long")
4811 }
4812
4813 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
4814 return err
4815 }
4816 if _, err := cw.WriteString(string("repo")); err != nil {
4817 return err
4818 }
4819
4820 if len(t.Repo) > 1000000 {
4821 return xerrors.Errorf("Value in field t.Repo was too long")
4822 }
4823
4824 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
4825 return err
4826 }
4827 if _, err := cw.WriteString(string(t.Repo)); err != nil {
4828 return err
4829 }
4830
4831 // t.DefaultBranch (string) (string)
4832 if len("defaultBranch") > 1000000 {
4833 return xerrors.Errorf("Value in field \"defaultBranch\" was too long")
4834 }
4835
4836 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("defaultBranch"))); err != nil {
4837 return err
4838 }
4839 if _, err := cw.WriteString(string("defaultBranch")); err != nil {
4840 return err
4841 }
4842
4843 if len(t.DefaultBranch) > 1000000 {
4844 return xerrors.Errorf("Value in field t.DefaultBranch was too long")
4845 }
4846
4847 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.DefaultBranch))); err != nil {
4848 return err
4849 }
4850 if _, err := cw.WriteString(string(t.DefaultBranch)); err != nil {
4851 return err
4852 }
4853 return nil
4854}
4855
4856func (t *Pipeline_TriggerRepo) UnmarshalCBOR(r io.Reader) (err error) {
4857 *t = Pipeline_TriggerRepo{}
4858
4859 cr := cbg.NewCborReader(r)
4860
4861 maj, extra, err := cr.ReadHeader()
4862 if err != nil {
4863 return err
4864 }
4865 defer func() {
4866 if err == io.EOF {
4867 err = io.ErrUnexpectedEOF
4868 }
4869 }()
4870
4871 if maj != cbg.MajMap {
4872 return fmt.Errorf("cbor input should be of type map")
4873 }
4874
4875 if extra > cbg.MaxLength {
4876 return fmt.Errorf("Pipeline_TriggerRepo: map struct too large (%d)", extra)
4877 }
4878
4879 n := extra
4880
4881 nameBuf := make([]byte, 13)
4882 for i := uint64(0); i < n; i++ {
4883 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4884 if err != nil {
4885 return err
4886 }
4887
4888 if !ok {
4889 // Field doesn't exist on this type, so ignore it
4890 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4891 return err
4892 }
4893 continue
4894 }
4895
4896 switch string(nameBuf[:nameLen]) {
4897 // t.Did (string) (string)
4898 case "did":
4899
4900 {
4901 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4902 if err != nil {
4903 return err
4904 }
4905
4906 t.Did = string(sval)
4907 }
4908 // t.Knot (string) (string)
4909 case "knot":
4910
4911 {
4912 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4913 if err != nil {
4914 return err
4915 }
4916
4917 t.Knot = string(sval)
4918 }
4919 // t.Repo (string) (string)
4920 case "repo":
4921
4922 {
4923 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4924 if err != nil {
4925 return err
4926 }
4927
4928 t.Repo = string(sval)
4929 }
4930 // t.DefaultBranch (string) (string)
4931 case "defaultBranch":
4932
4933 {
4934 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4935 if err != nil {
4936 return err
4937 }
4938
4939 t.DefaultBranch = string(sval)
4940 }
4941
4942 default:
4943 // Field doesn't exist on this type, so ignore it
4944 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4945 return err
4946 }
4947 }
4948 }
4949
4950 return nil
4951}
4952func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error {
4953 if t == nil {
4954 _, err := w.Write(cbg.CborNull)
4955 return err
4956 }
4957
4958 cw := cbg.NewCborWriter(w)
4959
4960 if _, err := cw.Write([]byte{164}); err != nil {
4961 return err
4962 }
4963
4964 // t.Raw (string) (string)
4965 if len("raw") > 1000000 {
4966 return xerrors.Errorf("Value in field \"raw\" was too long")
4967 }
4968
4969 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("raw"))); err != nil {
4970 return err
4971 }
4972 if _, err := cw.WriteString(string("raw")); err != nil {
4973 return err
4974 }
4975
4976 if len(t.Raw) > 1000000 {
4977 return xerrors.Errorf("Value in field t.Raw was too long")
4978 }
4979
4980 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Raw))); err != nil {
4981 return err
4982 }
4983 if _, err := cw.WriteString(string(t.Raw)); err != nil {
4984 return err
4985 }
4986
4987 // t.Name (string) (string)
4988 if len("name") > 1000000 {
4989 return xerrors.Errorf("Value in field \"name\" was too long")
4990 }
4991
4992 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
4993 return err
4994 }
4995 if _, err := cw.WriteString(string("name")); err != nil {
4996 return err
4997 }
4998
4999 if len(t.Name) > 1000000 {
5000 return xerrors.Errorf("Value in field t.Name was too long")
5001 }
5002
5003 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5004 return err
5005 }
5006 if _, err := cw.WriteString(string(t.Name)); err != nil {
5007 return err
5008 }
5009
5010 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
5011 if len("clone") > 1000000 {
5012 return xerrors.Errorf("Value in field \"clone\" was too long")
5013 }
5014
5015 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil {
5016 return err
5017 }
5018 if _, err := cw.WriteString(string("clone")); err != nil {
5019 return err
5020 }
5021
5022 if err := t.Clone.MarshalCBOR(cw); err != nil {
5023 return err
5024 }
5025
5026 // t.Engine (string) (string)
5027 if len("engine") > 1000000 {
5028 return xerrors.Errorf("Value in field \"engine\" was too long")
5029 }
5030
5031 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("engine"))); err != nil {
5032 return err
5033 }
5034 if _, err := cw.WriteString(string("engine")); err != nil {
5035 return err
5036 }
5037
5038 if len(t.Engine) > 1000000 {
5039 return xerrors.Errorf("Value in field t.Engine was too long")
5040 }
5041
5042 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Engine))); err != nil {
5043 return err
5044 }
5045 if _, err := cw.WriteString(string(t.Engine)); err != nil {
5046 return err
5047 }
5048 return nil
5049}
5050
5051func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) {
5052 *t = Pipeline_Workflow{}
5053
5054 cr := cbg.NewCborReader(r)
5055
5056 maj, extra, err := cr.ReadHeader()
5057 if err != nil {
5058 return err
5059 }
5060 defer func() {
5061 if err == io.EOF {
5062 err = io.ErrUnexpectedEOF
5063 }
5064 }()
5065
5066 if maj != cbg.MajMap {
5067 return fmt.Errorf("cbor input should be of type map")
5068 }
5069
5070 if extra > cbg.MaxLength {
5071 return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra)
5072 }
5073
5074 n := extra
5075
5076 nameBuf := make([]byte, 6)
5077 for i := uint64(0); i < n; i++ {
5078 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5079 if err != nil {
5080 return err
5081 }
5082
5083 if !ok {
5084 // Field doesn't exist on this type, so ignore it
5085 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5086 return err
5087 }
5088 continue
5089 }
5090
5091 switch string(nameBuf[:nameLen]) {
5092 // t.Raw (string) (string)
5093 case "raw":
5094
5095 {
5096 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5097 if err != nil {
5098 return err
5099 }
5100
5101 t.Raw = string(sval)
5102 }
5103 // t.Name (string) (string)
5104 case "name":
5105
5106 {
5107 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5108 if err != nil {
5109 return err
5110 }
5111
5112 t.Name = string(sval)
5113 }
5114 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
5115 case "clone":
5116
5117 {
5118
5119 b, err := cr.ReadByte()
5120 if err != nil {
5121 return err
5122 }
5123 if b != cbg.CborNull[0] {
5124 if err := cr.UnreadByte(); err != nil {
5125 return err
5126 }
5127 t.Clone = new(Pipeline_CloneOpts)
5128 if err := t.Clone.UnmarshalCBOR(cr); err != nil {
5129 return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err)
5130 }
5131 }
5132
5133 }
5134 // t.Engine (string) (string)
5135 case "engine":
5136
5137 {
5138 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5139 if err != nil {
5140 return err
5141 }
5142
5143 t.Engine = string(sval)
5144 }
5145
5146 default:
5147 // Field doesn't exist on this type, so ignore it
5148 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5149 return err
5150 }
5151 }
5152 }
5153
5154 return nil
5155}
5156func (t *PublicKey) MarshalCBOR(w io.Writer) error {
5157 if t == nil {
5158 _, err := w.Write(cbg.CborNull)
5159 return err
5160 }
5161
5162 cw := cbg.NewCborWriter(w)
5163
5164 if _, err := cw.Write([]byte{164}); err != nil {
5165 return err
5166 }
5167
5168 // t.Key (string) (string)
5169 if len("key") > 1000000 {
5170 return xerrors.Errorf("Value in field \"key\" was too long")
5171 }
5172
5173 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
5174 return err
5175 }
5176 if _, err := cw.WriteString(string("key")); err != nil {
5177 return err
5178 }
5179
5180 if len(t.Key) > 1000000 {
5181 return xerrors.Errorf("Value in field t.Key was too long")
5182 }
5183
5184 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
5185 return err
5186 }
5187 if _, err := cw.WriteString(string(t.Key)); err != nil {
5188 return err
5189 }
5190
5191 // t.Name (string) (string)
5192 if len("name") > 1000000 {
5193 return xerrors.Errorf("Value in field \"name\" was too long")
5194 }
5195
5196 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5197 return err
5198 }
5199 if _, err := cw.WriteString(string("name")); err != nil {
5200 return err
5201 }
5202
5203 if len(t.Name) > 1000000 {
5204 return xerrors.Errorf("Value in field t.Name was too long")
5205 }
5206
5207 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5208 return err
5209 }
5210 if _, err := cw.WriteString(string(t.Name)); err != nil {
5211 return err
5212 }
5213
5214 // t.LexiconTypeID (string) (string)
5215 if len("$type") > 1000000 {
5216 return xerrors.Errorf("Value in field \"$type\" was too long")
5217 }
5218
5219 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5220 return err
5221 }
5222 if _, err := cw.WriteString(string("$type")); err != nil {
5223 return err
5224 }
5225
5226 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil {
5227 return err
5228 }
5229 if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil {
5230 return err
5231 }
5232
5233 // t.CreatedAt (string) (string)
5234 if len("createdAt") > 1000000 {
5235 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5236 }
5237
5238 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5239 return err
5240 }
5241 if _, err := cw.WriteString(string("createdAt")); err != nil {
5242 return err
5243 }
5244
5245 if len(t.CreatedAt) > 1000000 {
5246 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5247 }
5248
5249 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5250 return err
5251 }
5252 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5253 return err
5254 }
5255 return nil
5256}
5257
5258func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) {
5259 *t = PublicKey{}
5260
5261 cr := cbg.NewCborReader(r)
5262
5263 maj, extra, err := cr.ReadHeader()
5264 if err != nil {
5265 return err
5266 }
5267 defer func() {
5268 if err == io.EOF {
5269 err = io.ErrUnexpectedEOF
5270 }
5271 }()
5272
5273 if maj != cbg.MajMap {
5274 return fmt.Errorf("cbor input should be of type map")
5275 }
5276
5277 if extra > cbg.MaxLength {
5278 return fmt.Errorf("PublicKey: map struct too large (%d)", extra)
5279 }
5280
5281 n := extra
5282
5283 nameBuf := make([]byte, 9)
5284 for i := uint64(0); i < n; i++ {
5285 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5286 if err != nil {
5287 return err
5288 }
5289
5290 if !ok {
5291 // Field doesn't exist on this type, so ignore it
5292 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5293 return err
5294 }
5295 continue
5296 }
5297
5298 switch string(nameBuf[:nameLen]) {
5299 // t.Key (string) (string)
5300 case "key":
5301
5302 {
5303 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5304 if err != nil {
5305 return err
5306 }
5307
5308 t.Key = string(sval)
5309 }
5310 // t.Name (string) (string)
5311 case "name":
5312
5313 {
5314 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5315 if err != nil {
5316 return err
5317 }
5318
5319 t.Name = string(sval)
5320 }
5321 // t.LexiconTypeID (string) (string)
5322 case "$type":
5323
5324 {
5325 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5326 if err != nil {
5327 return err
5328 }
5329
5330 t.LexiconTypeID = string(sval)
5331 }
5332 // t.CreatedAt (string) (string)
5333 case "createdAt":
5334
5335 {
5336 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5337 if err != nil {
5338 return err
5339 }
5340
5341 t.CreatedAt = string(sval)
5342 }
5343
5344 default:
5345 // Field doesn't exist on this type, so ignore it
5346 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5347 return err
5348 }
5349 }
5350 }
5351
5352 return nil
5353}
5354func (t *Repo) MarshalCBOR(w io.Writer) error {
5355 if t == nil {
5356 _, err := w.Write(cbg.CborNull)
5357 return err
5358 }
5359
5360 cw := cbg.NewCborWriter(w)
5361 fieldCount := 8
5362
5363 if t.Description == nil {
5364 fieldCount--
5365 }
5366
5367 if t.Source == nil {
5368 fieldCount--
5369 }
5370
5371 if t.Spindle == nil {
5372 fieldCount--
5373 }
5374
5375 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5376 return err
5377 }
5378
5379 // t.Knot (string) (string)
5380 if len("knot") > 1000000 {
5381 return xerrors.Errorf("Value in field \"knot\" was too long")
5382 }
5383
5384 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
5385 return err
5386 }
5387 if _, err := cw.WriteString(string("knot")); err != nil {
5388 return err
5389 }
5390
5391 if len(t.Knot) > 1000000 {
5392 return xerrors.Errorf("Value in field t.Knot was too long")
5393 }
5394
5395 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
5396 return err
5397 }
5398 if _, err := cw.WriteString(string(t.Knot)); err != nil {
5399 return err
5400 }
5401
5402 // t.Name (string) (string)
5403 if len("name") > 1000000 {
5404 return xerrors.Errorf("Value in field \"name\" was too long")
5405 }
5406
5407 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5408 return err
5409 }
5410 if _, err := cw.WriteString(string("name")); err != nil {
5411 return err
5412 }
5413
5414 if len(t.Name) > 1000000 {
5415 return xerrors.Errorf("Value in field t.Name was too long")
5416 }
5417
5418 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5419 return err
5420 }
5421 if _, err := cw.WriteString(string(t.Name)); err != nil {
5422 return err
5423 }
5424
5425 // t.LexiconTypeID (string) (string)
5426 if len("$type") > 1000000 {
5427 return xerrors.Errorf("Value in field \"$type\" was too long")
5428 }
5429
5430 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5431 return err
5432 }
5433 if _, err := cw.WriteString(string("$type")); err != nil {
5434 return err
5435 }
5436
5437 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil {
5438 return err
5439 }
5440 if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil {
5441 return err
5442 }
5443
5444 // t.Owner (string) (string)
5445 if len("owner") > 1000000 {
5446 return xerrors.Errorf("Value in field \"owner\" was too long")
5447 }
5448
5449 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
5450 return err
5451 }
5452 if _, err := cw.WriteString(string("owner")); err != nil {
5453 return err
5454 }
5455
5456 if len(t.Owner) > 1000000 {
5457 return xerrors.Errorf("Value in field t.Owner was too long")
5458 }
5459
5460 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {
5461 return err
5462 }
5463 if _, err := cw.WriteString(string(t.Owner)); err != nil {
5464 return err
5465 }
5466
5467 // t.Source (string) (string)
5468 if t.Source != nil {
5469
5470 if len("source") > 1000000 {
5471 return xerrors.Errorf("Value in field \"source\" was too long")
5472 }
5473
5474 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
5475 return err
5476 }
5477 if _, err := cw.WriteString(string("source")); err != nil {
5478 return err
5479 }
5480
5481 if t.Source == nil {
5482 if _, err := cw.Write(cbg.CborNull); err != nil {
5483 return err
5484 }
5485 } else {
5486 if len(*t.Source) > 1000000 {
5487 return xerrors.Errorf("Value in field t.Source was too long")
5488 }
5489
5490 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil {
5491 return err
5492 }
5493 if _, err := cw.WriteString(string(*t.Source)); err != nil {
5494 return err
5495 }
5496 }
5497 }
5498
5499 // t.Spindle (string) (string)
5500 if t.Spindle != nil {
5501
5502 if len("spindle") > 1000000 {
5503 return xerrors.Errorf("Value in field \"spindle\" was too long")
5504 }
5505
5506 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("spindle"))); err != nil {
5507 return err
5508 }
5509 if _, err := cw.WriteString(string("spindle")); err != nil {
5510 return err
5511 }
5512
5513 if t.Spindle == nil {
5514 if _, err := cw.Write(cbg.CborNull); err != nil {
5515 return err
5516 }
5517 } else {
5518 if len(*t.Spindle) > 1000000 {
5519 return xerrors.Errorf("Value in field t.Spindle was too long")
5520 }
5521
5522 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Spindle))); err != nil {
5523 return err
5524 }
5525 if _, err := cw.WriteString(string(*t.Spindle)); err != nil {
5526 return err
5527 }
5528 }
5529 }
5530
5531 // t.CreatedAt (string) (string)
5532 if len("createdAt") > 1000000 {
5533 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5534 }
5535
5536 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5537 return err
5538 }
5539 if _, err := cw.WriteString(string("createdAt")); err != nil {
5540 return err
5541 }
5542
5543 if len(t.CreatedAt) > 1000000 {
5544 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5545 }
5546
5547 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5548 return err
5549 }
5550 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5551 return err
5552 }
5553
5554 // t.Description (string) (string)
5555 if t.Description != nil {
5556
5557 if len("description") > 1000000 {
5558 return xerrors.Errorf("Value in field \"description\" was too long")
5559 }
5560
5561 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
5562 return err
5563 }
5564 if _, err := cw.WriteString(string("description")); err != nil {
5565 return err
5566 }
5567
5568 if t.Description == nil {
5569 if _, err := cw.Write(cbg.CborNull); err != nil {
5570 return err
5571 }
5572 } else {
5573 if len(*t.Description) > 1000000 {
5574 return xerrors.Errorf("Value in field t.Description was too long")
5575 }
5576
5577 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
5578 return err
5579 }
5580 if _, err := cw.WriteString(string(*t.Description)); err != nil {
5581 return err
5582 }
5583 }
5584 }
5585 return nil
5586}
5587
5588func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) {
5589 *t = Repo{}
5590
5591 cr := cbg.NewCborReader(r)
5592
5593 maj, extra, err := cr.ReadHeader()
5594 if err != nil {
5595 return err
5596 }
5597 defer func() {
5598 if err == io.EOF {
5599 err = io.ErrUnexpectedEOF
5600 }
5601 }()
5602
5603 if maj != cbg.MajMap {
5604 return fmt.Errorf("cbor input should be of type map")
5605 }
5606
5607 if extra > cbg.MaxLength {
5608 return fmt.Errorf("Repo: map struct too large (%d)", extra)
5609 }
5610
5611 n := extra
5612
5613 nameBuf := make([]byte, 11)
5614 for i := uint64(0); i < n; i++ {
5615 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5616 if err != nil {
5617 return err
5618 }
5619
5620 if !ok {
5621 // Field doesn't exist on this type, so ignore it
5622 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5623 return err
5624 }
5625 continue
5626 }
5627
5628 switch string(nameBuf[:nameLen]) {
5629 // t.Knot (string) (string)
5630 case "knot":
5631
5632 {
5633 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5634 if err != nil {
5635 return err
5636 }
5637
5638 t.Knot = string(sval)
5639 }
5640 // t.Name (string) (string)
5641 case "name":
5642
5643 {
5644 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5645 if err != nil {
5646 return err
5647 }
5648
5649 t.Name = string(sval)
5650 }
5651 // t.LexiconTypeID (string) (string)
5652 case "$type":
5653
5654 {
5655 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5656 if err != nil {
5657 return err
5658 }
5659
5660 t.LexiconTypeID = string(sval)
5661 }
5662 // t.Owner (string) (string)
5663 case "owner":
5664
5665 {
5666 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5667 if err != nil {
5668 return err
5669 }
5670
5671 t.Owner = string(sval)
5672 }
5673 // t.Source (string) (string)
5674 case "source":
5675
5676 {
5677 b, err := cr.ReadByte()
5678 if err != nil {
5679 return err
5680 }
5681 if b != cbg.CborNull[0] {
5682 if err := cr.UnreadByte(); err != nil {
5683 return err
5684 }
5685
5686 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5687 if err != nil {
5688 return err
5689 }
5690
5691 t.Source = (*string)(&sval)
5692 }
5693 }
5694 // t.Spindle (string) (string)
5695 case "spindle":
5696
5697 {
5698 b, err := cr.ReadByte()
5699 if err != nil {
5700 return err
5701 }
5702 if b != cbg.CborNull[0] {
5703 if err := cr.UnreadByte(); err != nil {
5704 return err
5705 }
5706
5707 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5708 if err != nil {
5709 return err
5710 }
5711
5712 t.Spindle = (*string)(&sval)
5713 }
5714 }
5715 // t.CreatedAt (string) (string)
5716 case "createdAt":
5717
5718 {
5719 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5720 if err != nil {
5721 return err
5722 }
5723
5724 t.CreatedAt = string(sval)
5725 }
5726 // t.Description (string) (string)
5727 case "description":
5728
5729 {
5730 b, err := cr.ReadByte()
5731 if err != nil {
5732 return err
5733 }
5734 if b != cbg.CborNull[0] {
5735 if err := cr.UnreadByte(); err != nil {
5736 return err
5737 }
5738
5739 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5740 if err != nil {
5741 return err
5742 }
5743
5744 t.Description = (*string)(&sval)
5745 }
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 *RepoArtifact) 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 := 6
5766
5767 if t.Tag == nil {
5768 fieldCount--
5769 }
5770
5771 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5772 return err
5773 }
5774
5775 // t.Tag (util.LexBytes) (slice)
5776 if t.Tag != nil {
5777
5778 if len("tag") > 1000000 {
5779 return xerrors.Errorf("Value in field \"tag\" was too long")
5780 }
5781
5782 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tag"))); err != nil {
5783 return err
5784 }
5785 if _, err := cw.WriteString(string("tag")); err != nil {
5786 return err
5787 }
5788
5789 if len(t.Tag) > 2097152 {
5790 return xerrors.Errorf("Byte array in field t.Tag was too long")
5791 }
5792
5793 if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Tag))); err != nil {
5794 return err
5795 }
5796
5797 if _, err := cw.Write(t.Tag); err != nil {
5798 return err
5799 }
5800
5801 }
5802
5803 // t.Name (string) (string)
5804 if len("name") > 1000000 {
5805 return xerrors.Errorf("Value in field \"name\" was too long")
5806 }
5807
5808 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5809 return err
5810 }
5811 if _, err := cw.WriteString(string("name")); err != nil {
5812 return err
5813 }
5814
5815 if len(t.Name) > 1000000 {
5816 return xerrors.Errorf("Value in field t.Name was too long")
5817 }
5818
5819 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5820 return err
5821 }
5822 if _, err := cw.WriteString(string(t.Name)); err != nil {
5823 return err
5824 }
5825
5826 // t.Repo (string) (string)
5827 if len("repo") > 1000000 {
5828 return xerrors.Errorf("Value in field \"repo\" was too long")
5829 }
5830
5831 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5832 return err
5833 }
5834 if _, err := cw.WriteString(string("repo")); err != nil {
5835 return err
5836 }
5837
5838 if len(t.Repo) > 1000000 {
5839 return xerrors.Errorf("Value in field t.Repo was too long")
5840 }
5841
5842 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
5843 return err
5844 }
5845 if _, err := cw.WriteString(string(t.Repo)); err != nil {
5846 return err
5847 }
5848
5849 // t.LexiconTypeID (string) (string)
5850 if len("$type") > 1000000 {
5851 return xerrors.Errorf("Value in field \"$type\" was too long")
5852 }
5853
5854 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5855 return err
5856 }
5857 if _, err := cw.WriteString(string("$type")); err != nil {
5858 return err
5859 }
5860
5861 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.artifact"))); err != nil {
5862 return err
5863 }
5864 if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil {
5865 return err
5866 }
5867
5868 // t.Artifact (util.LexBlob) (struct)
5869 if len("artifact") > 1000000 {
5870 return xerrors.Errorf("Value in field \"artifact\" was too long")
5871 }
5872
5873 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("artifact"))); err != nil {
5874 return err
5875 }
5876 if _, err := cw.WriteString(string("artifact")); err != nil {
5877 return err
5878 }
5879
5880 if err := t.Artifact.MarshalCBOR(cw); err != nil {
5881 return err
5882 }
5883
5884 // t.CreatedAt (string) (string)
5885 if len("createdAt") > 1000000 {
5886 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5887 }
5888
5889 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5890 return err
5891 }
5892 if _, err := cw.WriteString(string("createdAt")); err != nil {
5893 return err
5894 }
5895
5896 if len(t.CreatedAt) > 1000000 {
5897 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5898 }
5899
5900 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5901 return err
5902 }
5903 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5904 return err
5905 }
5906 return nil
5907}
5908
5909func (t *RepoArtifact) UnmarshalCBOR(r io.Reader) (err error) {
5910 *t = RepoArtifact{}
5911
5912 cr := cbg.NewCborReader(r)
5913
5914 maj, extra, err := cr.ReadHeader()
5915 if err != nil {
5916 return err
5917 }
5918 defer func() {
5919 if err == io.EOF {
5920 err = io.ErrUnexpectedEOF
5921 }
5922 }()
5923
5924 if maj != cbg.MajMap {
5925 return fmt.Errorf("cbor input should be of type map")
5926 }
5927
5928 if extra > cbg.MaxLength {
5929 return fmt.Errorf("RepoArtifact: map struct too large (%d)", extra)
5930 }
5931
5932 n := extra
5933
5934 nameBuf := make([]byte, 9)
5935 for i := uint64(0); i < n; i++ {
5936 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5937 if err != nil {
5938 return err
5939 }
5940
5941 if !ok {
5942 // Field doesn't exist on this type, so ignore it
5943 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5944 return err
5945 }
5946 continue
5947 }
5948
5949 switch string(nameBuf[:nameLen]) {
5950 // t.Tag (util.LexBytes) (slice)
5951 case "tag":
5952
5953 maj, extra, err = cr.ReadHeader()
5954 if err != nil {
5955 return err
5956 }
5957
5958 if extra > 2097152 {
5959 return fmt.Errorf("t.Tag: byte array too large (%d)", extra)
5960 }
5961 if maj != cbg.MajByteString {
5962 return fmt.Errorf("expected byte array")
5963 }
5964
5965 if extra > 0 {
5966 t.Tag = make([]uint8, extra)
5967 }
5968
5969 if _, err := io.ReadFull(cr, t.Tag); err != nil {
5970 return err
5971 }
5972
5973 // t.Name (string) (string)
5974 case "name":
5975
5976 {
5977 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5978 if err != nil {
5979 return err
5980 }
5981
5982 t.Name = string(sval)
5983 }
5984 // t.Repo (string) (string)
5985 case "repo":
5986
5987 {
5988 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5989 if err != nil {
5990 return err
5991 }
5992
5993 t.Repo = string(sval)
5994 }
5995 // t.LexiconTypeID (string) (string)
5996 case "$type":
5997
5998 {
5999 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6000 if err != nil {
6001 return err
6002 }
6003
6004 t.LexiconTypeID = string(sval)
6005 }
6006 // t.Artifact (util.LexBlob) (struct)
6007 case "artifact":
6008
6009 {
6010
6011 b, err := cr.ReadByte()
6012 if err != nil {
6013 return err
6014 }
6015 if b != cbg.CborNull[0] {
6016 if err := cr.UnreadByte(); err != nil {
6017 return err
6018 }
6019 t.Artifact = new(util.LexBlob)
6020 if err := t.Artifact.UnmarshalCBOR(cr); err != nil {
6021 return xerrors.Errorf("unmarshaling t.Artifact pointer: %w", err)
6022 }
6023 }
6024
6025 }
6026 // t.CreatedAt (string) (string)
6027 case "createdAt":
6028
6029 {
6030 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6031 if err != nil {
6032 return err
6033 }
6034
6035 t.CreatedAt = string(sval)
6036 }
6037
6038 default:
6039 // Field doesn't exist on this type, so ignore it
6040 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6041 return err
6042 }
6043 }
6044 }
6045
6046 return nil
6047}
6048func (t *RepoCollaborator) MarshalCBOR(w io.Writer) error {
6049 if t == nil {
6050 _, err := w.Write(cbg.CborNull)
6051 return err
6052 }
6053
6054 cw := cbg.NewCborWriter(w)
6055
6056 if _, err := cw.Write([]byte{164}); err != nil {
6057 return err
6058 }
6059
6060 // t.Repo (string) (string)
6061 if len("repo") > 1000000 {
6062 return xerrors.Errorf("Value in field \"repo\" was too long")
6063 }
6064
6065 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6066 return err
6067 }
6068 if _, err := cw.WriteString(string("repo")); err != nil {
6069 return err
6070 }
6071
6072 if len(t.Repo) > 1000000 {
6073 return xerrors.Errorf("Value in field t.Repo was too long")
6074 }
6075
6076 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
6077 return err
6078 }
6079 if _, err := cw.WriteString(string(t.Repo)); err != nil {
6080 return err
6081 }
6082
6083 // t.LexiconTypeID (string) (string)
6084 if len("$type") > 1000000 {
6085 return xerrors.Errorf("Value in field \"$type\" was too long")
6086 }
6087
6088 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6089 return err
6090 }
6091 if _, err := cw.WriteString(string("$type")); err != nil {
6092 return err
6093 }
6094
6095 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.collaborator"))); err != nil {
6096 return err
6097 }
6098 if _, err := cw.WriteString(string("sh.tangled.repo.collaborator")); err != nil {
6099 return err
6100 }
6101
6102 // t.Subject (string) (string)
6103 if len("subject") > 1000000 {
6104 return xerrors.Errorf("Value in field \"subject\" was too long")
6105 }
6106
6107 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
6108 return err
6109 }
6110 if _, err := cw.WriteString(string("subject")); err != nil {
6111 return err
6112 }
6113
6114 if len(t.Subject) > 1000000 {
6115 return xerrors.Errorf("Value in field t.Subject was too long")
6116 }
6117
6118 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
6119 return err
6120 }
6121 if _, err := cw.WriteString(string(t.Subject)); err != nil {
6122 return err
6123 }
6124
6125 // t.CreatedAt (string) (string)
6126 if len("createdAt") > 1000000 {
6127 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6128 }
6129
6130 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6131 return err
6132 }
6133 if _, err := cw.WriteString(string("createdAt")); err != nil {
6134 return err
6135 }
6136
6137 if len(t.CreatedAt) > 1000000 {
6138 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6139 }
6140
6141 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6142 return err
6143 }
6144 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6145 return err
6146 }
6147 return nil
6148}
6149
6150func (t *RepoCollaborator) UnmarshalCBOR(r io.Reader) (err error) {
6151 *t = RepoCollaborator{}
6152
6153 cr := cbg.NewCborReader(r)
6154
6155 maj, extra, err := cr.ReadHeader()
6156 if err != nil {
6157 return err
6158 }
6159 defer func() {
6160 if err == io.EOF {
6161 err = io.ErrUnexpectedEOF
6162 }
6163 }()
6164
6165 if maj != cbg.MajMap {
6166 return fmt.Errorf("cbor input should be of type map")
6167 }
6168
6169 if extra > cbg.MaxLength {
6170 return fmt.Errorf("RepoCollaborator: map struct too large (%d)", extra)
6171 }
6172
6173 n := extra
6174
6175 nameBuf := make([]byte, 9)
6176 for i := uint64(0); i < n; i++ {
6177 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6178 if err != nil {
6179 return err
6180 }
6181
6182 if !ok {
6183 // Field doesn't exist on this type, so ignore it
6184 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6185 return err
6186 }
6187 continue
6188 }
6189
6190 switch string(nameBuf[:nameLen]) {
6191 // t.Repo (string) (string)
6192 case "repo":
6193
6194 {
6195 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6196 if err != nil {
6197 return err
6198 }
6199
6200 t.Repo = string(sval)
6201 }
6202 // t.LexiconTypeID (string) (string)
6203 case "$type":
6204
6205 {
6206 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6207 if err != nil {
6208 return err
6209 }
6210
6211 t.LexiconTypeID = string(sval)
6212 }
6213 // t.Subject (string) (string)
6214 case "subject":
6215
6216 {
6217 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6218 if err != nil {
6219 return err
6220 }
6221
6222 t.Subject = string(sval)
6223 }
6224 // t.CreatedAt (string) (string)
6225 case "createdAt":
6226
6227 {
6228 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6229 if err != nil {
6230 return err
6231 }
6232
6233 t.CreatedAt = string(sval)
6234 }
6235
6236 default:
6237 // Field doesn't exist on this type, so ignore it
6238 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6239 return err
6240 }
6241 }
6242 }
6243
6244 return nil
6245}
6246func (t *RepoIssue) MarshalCBOR(w io.Writer) error {
6247 if t == nil {
6248 _, err := w.Write(cbg.CborNull)
6249 return err
6250 }
6251
6252 cw := cbg.NewCborWriter(w)
6253 fieldCount := 5
6254
6255 if t.Body == nil {
6256 fieldCount--
6257 }
6258
6259 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6260 return err
6261 }
6262
6263 // t.Body (string) (string)
6264 if t.Body != nil {
6265
6266 if len("body") > 1000000 {
6267 return xerrors.Errorf("Value in field \"body\" was too long")
6268 }
6269
6270 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
6271 return err
6272 }
6273 if _, err := cw.WriteString(string("body")); err != nil {
6274 return err
6275 }
6276
6277 if t.Body == nil {
6278 if _, err := cw.Write(cbg.CborNull); err != nil {
6279 return err
6280 }
6281 } else {
6282 if len(*t.Body) > 1000000 {
6283 return xerrors.Errorf("Value in field t.Body was too long")
6284 }
6285
6286 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
6287 return err
6288 }
6289 if _, err := cw.WriteString(string(*t.Body)); err != nil {
6290 return err
6291 }
6292 }
6293 }
6294
6295 // t.Repo (string) (string)
6296 if len("repo") > 1000000 {
6297 return xerrors.Errorf("Value in field \"repo\" was too long")
6298 }
6299
6300 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6301 return err
6302 }
6303 if _, err := cw.WriteString(string("repo")); err != nil {
6304 return err
6305 }
6306
6307 if len(t.Repo) > 1000000 {
6308 return xerrors.Errorf("Value in field t.Repo was too long")
6309 }
6310
6311 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
6312 return err
6313 }
6314 if _, err := cw.WriteString(string(t.Repo)); err != nil {
6315 return err
6316 }
6317
6318 // t.LexiconTypeID (string) (string)
6319 if len("$type") > 1000000 {
6320 return xerrors.Errorf("Value in field \"$type\" was too long")
6321 }
6322
6323 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6324 return err
6325 }
6326 if _, err := cw.WriteString(string("$type")); err != nil {
6327 return err
6328 }
6329
6330 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil {
6331 return err
6332 }
6333 if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil {
6334 return err
6335 }
6336
6337 // t.Title (string) (string)
6338 if len("title") > 1000000 {
6339 return xerrors.Errorf("Value in field \"title\" was too long")
6340 }
6341
6342 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
6343 return err
6344 }
6345 if _, err := cw.WriteString(string("title")); err != nil {
6346 return err
6347 }
6348
6349 if len(t.Title) > 1000000 {
6350 return xerrors.Errorf("Value in field t.Title was too long")
6351 }
6352
6353 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
6354 return err
6355 }
6356 if _, err := cw.WriteString(string(t.Title)); err != nil {
6357 return err
6358 }
6359
6360 // t.CreatedAt (string) (string)
6361 if len("createdAt") > 1000000 {
6362 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6363 }
6364
6365 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6366 return err
6367 }
6368 if _, err := cw.WriteString(string("createdAt")); err != nil {
6369 return err
6370 }
6371
6372 if len(t.CreatedAt) > 1000000 {
6373 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6374 }
6375
6376 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6377 return err
6378 }
6379 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6380 return err
6381 }
6382 return nil
6383}
6384
6385func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) {
6386 *t = RepoIssue{}
6387
6388 cr := cbg.NewCborReader(r)
6389
6390 maj, extra, err := cr.ReadHeader()
6391 if err != nil {
6392 return err
6393 }
6394 defer func() {
6395 if err == io.EOF {
6396 err = io.ErrUnexpectedEOF
6397 }
6398 }()
6399
6400 if maj != cbg.MajMap {
6401 return fmt.Errorf("cbor input should be of type map")
6402 }
6403
6404 if extra > cbg.MaxLength {
6405 return fmt.Errorf("RepoIssue: map struct too large (%d)", extra)
6406 }
6407
6408 n := extra
6409
6410 nameBuf := make([]byte, 9)
6411 for i := uint64(0); i < n; i++ {
6412 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6413 if err != nil {
6414 return err
6415 }
6416
6417 if !ok {
6418 // Field doesn't exist on this type, so ignore it
6419 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6420 return err
6421 }
6422 continue
6423 }
6424
6425 switch string(nameBuf[:nameLen]) {
6426 // t.Body (string) (string)
6427 case "body":
6428
6429 {
6430 b, err := cr.ReadByte()
6431 if err != nil {
6432 return err
6433 }
6434 if b != cbg.CborNull[0] {
6435 if err := cr.UnreadByte(); err != nil {
6436 return err
6437 }
6438
6439 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6440 if err != nil {
6441 return err
6442 }
6443
6444 t.Body = (*string)(&sval)
6445 }
6446 }
6447 // t.Repo (string) (string)
6448 case "repo":
6449
6450 {
6451 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6452 if err != nil {
6453 return err
6454 }
6455
6456 t.Repo = string(sval)
6457 }
6458 // t.LexiconTypeID (string) (string)
6459 case "$type":
6460
6461 {
6462 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6463 if err != nil {
6464 return err
6465 }
6466
6467 t.LexiconTypeID = string(sval)
6468 }
6469 // t.Title (string) (string)
6470 case "title":
6471
6472 {
6473 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6474 if err != nil {
6475 return err
6476 }
6477
6478 t.Title = string(sval)
6479 }
6480 // t.CreatedAt (string) (string)
6481 case "createdAt":
6482
6483 {
6484 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6485 if err != nil {
6486 return err
6487 }
6488
6489 t.CreatedAt = string(sval)
6490 }
6491
6492 default:
6493 // Field doesn't exist on this type, so ignore it
6494 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6495 return err
6496 }
6497 }
6498 }
6499
6500 return nil
6501}
6502func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error {
6503 if t == nil {
6504 _, err := w.Write(cbg.CborNull)
6505 return err
6506 }
6507
6508 cw := cbg.NewCborWriter(w)
6509 fieldCount := 5
6510
6511 if t.ReplyTo == nil {
6512 fieldCount--
6513 }
6514
6515 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6516 return err
6517 }
6518
6519 // t.Body (string) (string)
6520 if len("body") > 1000000 {
6521 return xerrors.Errorf("Value in field \"body\" was too long")
6522 }
6523
6524 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
6525 return err
6526 }
6527 if _, err := cw.WriteString(string("body")); err != nil {
6528 return err
6529 }
6530
6531 if len(t.Body) > 1000000 {
6532 return xerrors.Errorf("Value in field t.Body was too long")
6533 }
6534
6535 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
6536 return err
6537 }
6538 if _, err := cw.WriteString(string(t.Body)); err != nil {
6539 return err
6540 }
6541
6542 // t.LexiconTypeID (string) (string)
6543 if len("$type") > 1000000 {
6544 return xerrors.Errorf("Value in field \"$type\" was too long")
6545 }
6546
6547 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6548 return err
6549 }
6550 if _, err := cw.WriteString(string("$type")); err != nil {
6551 return err
6552 }
6553
6554 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil {
6555 return err
6556 }
6557 if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil {
6558 return err
6559 }
6560
6561 // t.Issue (string) (string)
6562 if len("issue") > 1000000 {
6563 return xerrors.Errorf("Value in field \"issue\" was too long")
6564 }
6565
6566 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
6567 return err
6568 }
6569 if _, err := cw.WriteString(string("issue")); err != nil {
6570 return err
6571 }
6572
6573 if len(t.Issue) > 1000000 {
6574 return xerrors.Errorf("Value in field t.Issue was too long")
6575 }
6576
6577 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
6578 return err
6579 }
6580 if _, err := cw.WriteString(string(t.Issue)); err != nil {
6581 return err
6582 }
6583
6584 // t.ReplyTo (string) (string)
6585 if t.ReplyTo != nil {
6586
6587 if len("replyTo") > 1000000 {
6588 return xerrors.Errorf("Value in field \"replyTo\" was too long")
6589 }
6590
6591 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("replyTo"))); err != nil {
6592 return err
6593 }
6594 if _, err := cw.WriteString(string("replyTo")); err != nil {
6595 return err
6596 }
6597
6598 if t.ReplyTo == nil {
6599 if _, err := cw.Write(cbg.CborNull); err != nil {
6600 return err
6601 }
6602 } else {
6603 if len(*t.ReplyTo) > 1000000 {
6604 return xerrors.Errorf("Value in field t.ReplyTo was too long")
6605 }
6606
6607 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ReplyTo))); err != nil {
6608 return err
6609 }
6610 if _, err := cw.WriteString(string(*t.ReplyTo)); err != nil {
6611 return err
6612 }
6613 }
6614 }
6615
6616 // t.CreatedAt (string) (string)
6617 if len("createdAt") > 1000000 {
6618 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6619 }
6620
6621 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6622 return err
6623 }
6624 if _, err := cw.WriteString(string("createdAt")); err != nil {
6625 return err
6626 }
6627
6628 if len(t.CreatedAt) > 1000000 {
6629 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6630 }
6631
6632 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6633 return err
6634 }
6635 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6636 return err
6637 }
6638 return nil
6639}
6640
6641func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) {
6642 *t = RepoIssueComment{}
6643
6644 cr := cbg.NewCborReader(r)
6645
6646 maj, extra, err := cr.ReadHeader()
6647 if err != nil {
6648 return err
6649 }
6650 defer func() {
6651 if err == io.EOF {
6652 err = io.ErrUnexpectedEOF
6653 }
6654 }()
6655
6656 if maj != cbg.MajMap {
6657 return fmt.Errorf("cbor input should be of type map")
6658 }
6659
6660 if extra > cbg.MaxLength {
6661 return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra)
6662 }
6663
6664 n := extra
6665
6666 nameBuf := make([]byte, 9)
6667 for i := uint64(0); i < n; i++ {
6668 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6669 if err != nil {
6670 return err
6671 }
6672
6673 if !ok {
6674 // Field doesn't exist on this type, so ignore it
6675 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6676 return err
6677 }
6678 continue
6679 }
6680
6681 switch string(nameBuf[:nameLen]) {
6682 // t.Body (string) (string)
6683 case "body":
6684
6685 {
6686 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6687 if err != nil {
6688 return err
6689 }
6690
6691 t.Body = string(sval)
6692 }
6693 // t.LexiconTypeID (string) (string)
6694 case "$type":
6695
6696 {
6697 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6698 if err != nil {
6699 return err
6700 }
6701
6702 t.LexiconTypeID = string(sval)
6703 }
6704 // t.Issue (string) (string)
6705 case "issue":
6706
6707 {
6708 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6709 if err != nil {
6710 return err
6711 }
6712
6713 t.Issue = string(sval)
6714 }
6715 // t.ReplyTo (string) (string)
6716 case "replyTo":
6717
6718 {
6719 b, err := cr.ReadByte()
6720 if err != nil {
6721 return err
6722 }
6723 if b != cbg.CborNull[0] {
6724 if err := cr.UnreadByte(); err != nil {
6725 return err
6726 }
6727
6728 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6729 if err != nil {
6730 return err
6731 }
6732
6733 t.ReplyTo = (*string)(&sval)
6734 }
6735 }
6736 // t.CreatedAt (string) (string)
6737 case "createdAt":
6738
6739 {
6740 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6741 if err != nil {
6742 return err
6743 }
6744
6745 t.CreatedAt = string(sval)
6746 }
6747
6748 default:
6749 // Field doesn't exist on this type, so ignore it
6750 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6751 return err
6752 }
6753 }
6754 }
6755
6756 return nil
6757}
6758func (t *RepoIssueState) MarshalCBOR(w io.Writer) error {
6759 if t == nil {
6760 _, err := w.Write(cbg.CborNull)
6761 return err
6762 }
6763
6764 cw := cbg.NewCborWriter(w)
6765
6766 if _, err := cw.Write([]byte{163}); err != nil {
6767 return err
6768 }
6769
6770 // t.LexiconTypeID (string) (string)
6771 if len("$type") > 1000000 {
6772 return xerrors.Errorf("Value in field \"$type\" was too long")
6773 }
6774
6775 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6776 return err
6777 }
6778 if _, err := cw.WriteString(string("$type")); err != nil {
6779 return err
6780 }
6781
6782 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil {
6783 return err
6784 }
6785 if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil {
6786 return err
6787 }
6788
6789 // t.Issue (string) (string)
6790 if len("issue") > 1000000 {
6791 return xerrors.Errorf("Value in field \"issue\" was too long")
6792 }
6793
6794 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
6795 return err
6796 }
6797 if _, err := cw.WriteString(string("issue")); err != nil {
6798 return err
6799 }
6800
6801 if len(t.Issue) > 1000000 {
6802 return xerrors.Errorf("Value in field t.Issue was too long")
6803 }
6804
6805 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
6806 return err
6807 }
6808 if _, err := cw.WriteString(string(t.Issue)); err != nil {
6809 return err
6810 }
6811
6812 // t.State (string) (string)
6813 if len("state") > 1000000 {
6814 return xerrors.Errorf("Value in field \"state\" was too long")
6815 }
6816
6817 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil {
6818 return err
6819 }
6820 if _, err := cw.WriteString(string("state")); err != nil {
6821 return err
6822 }
6823
6824 if len(t.State) > 1000000 {
6825 return xerrors.Errorf("Value in field t.State was too long")
6826 }
6827
6828 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil {
6829 return err
6830 }
6831 if _, err := cw.WriteString(string(t.State)); err != nil {
6832 return err
6833 }
6834 return nil
6835}
6836
6837func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) {
6838 *t = RepoIssueState{}
6839
6840 cr := cbg.NewCborReader(r)
6841
6842 maj, extra, err := cr.ReadHeader()
6843 if err != nil {
6844 return err
6845 }
6846 defer func() {
6847 if err == io.EOF {
6848 err = io.ErrUnexpectedEOF
6849 }
6850 }()
6851
6852 if maj != cbg.MajMap {
6853 return fmt.Errorf("cbor input should be of type map")
6854 }
6855
6856 if extra > cbg.MaxLength {
6857 return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra)
6858 }
6859
6860 n := extra
6861
6862 nameBuf := make([]byte, 5)
6863 for i := uint64(0); i < n; i++ {
6864 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6865 if err != nil {
6866 return err
6867 }
6868
6869 if !ok {
6870 // Field doesn't exist on this type, so ignore it
6871 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6872 return err
6873 }
6874 continue
6875 }
6876
6877 switch string(nameBuf[:nameLen]) {
6878 // t.LexiconTypeID (string) (string)
6879 case "$type":
6880
6881 {
6882 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6883 if err != nil {
6884 return err
6885 }
6886
6887 t.LexiconTypeID = string(sval)
6888 }
6889 // t.Issue (string) (string)
6890 case "issue":
6891
6892 {
6893 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6894 if err != nil {
6895 return err
6896 }
6897
6898 t.Issue = string(sval)
6899 }
6900 // t.State (string) (string)
6901 case "state":
6902
6903 {
6904 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6905 if err != nil {
6906 return err
6907 }
6908
6909 t.State = string(sval)
6910 }
6911
6912 default:
6913 // Field doesn't exist on this type, so ignore it
6914 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6915 return err
6916 }
6917 }
6918 }
6919
6920 return nil
6921}
6922func (t *RepoPull) MarshalCBOR(w io.Writer) error {
6923 if t == nil {
6924 _, err := w.Write(cbg.CborNull)
6925 return err
6926 }
6927
6928 cw := cbg.NewCborWriter(w)
6929 fieldCount := 7
6930
6931 if t.Body == nil {
6932 fieldCount--
6933 }
6934
6935 if t.Source == nil {
6936 fieldCount--
6937 }
6938
6939 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6940 return err
6941 }
6942
6943 // t.Body (string) (string)
6944 if t.Body != nil {
6945
6946 if len("body") > 1000000 {
6947 return xerrors.Errorf("Value in field \"body\" was too long")
6948 }
6949
6950 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
6951 return err
6952 }
6953 if _, err := cw.WriteString(string("body")); err != nil {
6954 return err
6955 }
6956
6957 if t.Body == nil {
6958 if _, err := cw.Write(cbg.CborNull); err != nil {
6959 return err
6960 }
6961 } else {
6962 if len(*t.Body) > 1000000 {
6963 return xerrors.Errorf("Value in field t.Body was too long")
6964 }
6965
6966 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
6967 return err
6968 }
6969 if _, err := cw.WriteString(string(*t.Body)); err != nil {
6970 return err
6971 }
6972 }
6973 }
6974
6975 // t.LexiconTypeID (string) (string)
6976 if len("$type") > 1000000 {
6977 return xerrors.Errorf("Value in field \"$type\" was too long")
6978 }
6979
6980 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6981 return err
6982 }
6983 if _, err := cw.WriteString(string("$type")); err != nil {
6984 return err
6985 }
6986
6987 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil {
6988 return err
6989 }
6990 if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil {
6991 return err
6992 }
6993
6994 // t.Patch (string) (string)
6995 if len("patch") > 1000000 {
6996 return xerrors.Errorf("Value in field \"patch\" was too long")
6997 }
6998
6999 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil {
7000 return err
7001 }
7002 if _, err := cw.WriteString(string("patch")); err != nil {
7003 return err
7004 }
7005
7006 if len(t.Patch) > 1000000 {
7007 return xerrors.Errorf("Value in field t.Patch was too long")
7008 }
7009
7010 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Patch))); err != nil {
7011 return err
7012 }
7013 if _, err := cw.WriteString(string(t.Patch)); err != nil {
7014 return err
7015 }
7016
7017 // t.Title (string) (string)
7018 if len("title") > 1000000 {
7019 return xerrors.Errorf("Value in field \"title\" was too long")
7020 }
7021
7022 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
7023 return err
7024 }
7025 if _, err := cw.WriteString(string("title")); err != nil {
7026 return err
7027 }
7028
7029 if len(t.Title) > 1000000 {
7030 return xerrors.Errorf("Value in field t.Title was too long")
7031 }
7032
7033 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
7034 return err
7035 }
7036 if _, err := cw.WriteString(string(t.Title)); err != nil {
7037 return err
7038 }
7039
7040 // t.Source (tangled.RepoPull_Source) (struct)
7041 if t.Source != nil {
7042
7043 if len("source") > 1000000 {
7044 return xerrors.Errorf("Value in field \"source\" was too long")
7045 }
7046
7047 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
7048 return err
7049 }
7050 if _, err := cw.WriteString(string("source")); err != nil {
7051 return err
7052 }
7053
7054 if err := t.Source.MarshalCBOR(cw); err != nil {
7055 return err
7056 }
7057 }
7058
7059 // t.Target (tangled.RepoPull_Target) (struct)
7060 if len("target") > 1000000 {
7061 return xerrors.Errorf("Value in field \"target\" was too long")
7062 }
7063
7064 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("target"))); err != nil {
7065 return err
7066 }
7067 if _, err := cw.WriteString(string("target")); err != nil {
7068 return err
7069 }
7070
7071 if err := t.Target.MarshalCBOR(cw); err != nil {
7072 return err
7073 }
7074
7075 // t.CreatedAt (string) (string)
7076 if len("createdAt") > 1000000 {
7077 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7078 }
7079
7080 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7081 return err
7082 }
7083 if _, err := cw.WriteString(string("createdAt")); err != nil {
7084 return err
7085 }
7086
7087 if len(t.CreatedAt) > 1000000 {
7088 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7089 }
7090
7091 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7092 return err
7093 }
7094 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7095 return err
7096 }
7097 return nil
7098}
7099
7100func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) {
7101 *t = RepoPull{}
7102
7103 cr := cbg.NewCborReader(r)
7104
7105 maj, extra, err := cr.ReadHeader()
7106 if err != nil {
7107 return err
7108 }
7109 defer func() {
7110 if err == io.EOF {
7111 err = io.ErrUnexpectedEOF
7112 }
7113 }()
7114
7115 if maj != cbg.MajMap {
7116 return fmt.Errorf("cbor input should be of type map")
7117 }
7118
7119 if extra > cbg.MaxLength {
7120 return fmt.Errorf("RepoPull: map struct too large (%d)", extra)
7121 }
7122
7123 n := extra
7124
7125 nameBuf := make([]byte, 9)
7126 for i := uint64(0); i < n; i++ {
7127 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7128 if err != nil {
7129 return err
7130 }
7131
7132 if !ok {
7133 // Field doesn't exist on this type, so ignore it
7134 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7135 return err
7136 }
7137 continue
7138 }
7139
7140 switch string(nameBuf[:nameLen]) {
7141 // t.Body (string) (string)
7142 case "body":
7143
7144 {
7145 b, err := cr.ReadByte()
7146 if err != nil {
7147 return err
7148 }
7149 if b != cbg.CborNull[0] {
7150 if err := cr.UnreadByte(); err != nil {
7151 return err
7152 }
7153
7154 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7155 if err != nil {
7156 return err
7157 }
7158
7159 t.Body = (*string)(&sval)
7160 }
7161 }
7162 // t.LexiconTypeID (string) (string)
7163 case "$type":
7164
7165 {
7166 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7167 if err != nil {
7168 return err
7169 }
7170
7171 t.LexiconTypeID = string(sval)
7172 }
7173 // t.Patch (string) (string)
7174 case "patch":
7175
7176 {
7177 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7178 if err != nil {
7179 return err
7180 }
7181
7182 t.Patch = string(sval)
7183 }
7184 // t.Title (string) (string)
7185 case "title":
7186
7187 {
7188 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7189 if err != nil {
7190 return err
7191 }
7192
7193 t.Title = string(sval)
7194 }
7195 // t.Source (tangled.RepoPull_Source) (struct)
7196 case "source":
7197
7198 {
7199
7200 b, err := cr.ReadByte()
7201 if err != nil {
7202 return err
7203 }
7204 if b != cbg.CborNull[0] {
7205 if err := cr.UnreadByte(); err != nil {
7206 return err
7207 }
7208 t.Source = new(RepoPull_Source)
7209 if err := t.Source.UnmarshalCBOR(cr); err != nil {
7210 return xerrors.Errorf("unmarshaling t.Source pointer: %w", err)
7211 }
7212 }
7213
7214 }
7215 // t.Target (tangled.RepoPull_Target) (struct)
7216 case "target":
7217
7218 {
7219
7220 b, err := cr.ReadByte()
7221 if err != nil {
7222 return err
7223 }
7224 if b != cbg.CborNull[0] {
7225 if err := cr.UnreadByte(); err != nil {
7226 return err
7227 }
7228 t.Target = new(RepoPull_Target)
7229 if err := t.Target.UnmarshalCBOR(cr); err != nil {
7230 return xerrors.Errorf("unmarshaling t.Target pointer: %w", err)
7231 }
7232 }
7233
7234 }
7235 // t.CreatedAt (string) (string)
7236 case "createdAt":
7237
7238 {
7239 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7240 if err != nil {
7241 return err
7242 }
7243
7244 t.CreatedAt = string(sval)
7245 }
7246
7247 default:
7248 // Field doesn't exist on this type, so ignore it
7249 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7250 return err
7251 }
7252 }
7253 }
7254
7255 return nil
7256}
7257func (t *RepoPullComment) MarshalCBOR(w io.Writer) error {
7258 if t == nil {
7259 _, err := w.Write(cbg.CborNull)
7260 return err
7261 }
7262
7263 cw := cbg.NewCborWriter(w)
7264
7265 if _, err := cw.Write([]byte{164}); err != nil {
7266 return err
7267 }
7268
7269 // t.Body (string) (string)
7270 if len("body") > 1000000 {
7271 return xerrors.Errorf("Value in field \"body\" was too long")
7272 }
7273
7274 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
7275 return err
7276 }
7277 if _, err := cw.WriteString(string("body")); err != nil {
7278 return err
7279 }
7280
7281 if len(t.Body) > 1000000 {
7282 return xerrors.Errorf("Value in field t.Body was too long")
7283 }
7284
7285 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
7286 return err
7287 }
7288 if _, err := cw.WriteString(string(t.Body)); err != nil {
7289 return err
7290 }
7291
7292 // t.Pull (string) (string)
7293 if len("pull") > 1000000 {
7294 return xerrors.Errorf("Value in field \"pull\" was too long")
7295 }
7296
7297 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
7298 return err
7299 }
7300 if _, err := cw.WriteString(string("pull")); err != nil {
7301 return err
7302 }
7303
7304 if len(t.Pull) > 1000000 {
7305 return xerrors.Errorf("Value in field t.Pull was too long")
7306 }
7307
7308 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
7309 return err
7310 }
7311 if _, err := cw.WriteString(string(t.Pull)); err != nil {
7312 return err
7313 }
7314
7315 // t.LexiconTypeID (string) (string)
7316 if len("$type") > 1000000 {
7317 return xerrors.Errorf("Value in field \"$type\" was too long")
7318 }
7319
7320 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7321 return err
7322 }
7323 if _, err := cw.WriteString(string("$type")); err != nil {
7324 return err
7325 }
7326
7327 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.comment"))); err != nil {
7328 return err
7329 }
7330 if _, err := cw.WriteString(string("sh.tangled.repo.pull.comment")); err != nil {
7331 return err
7332 }
7333
7334 // t.CreatedAt (string) (string)
7335 if len("createdAt") > 1000000 {
7336 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7337 }
7338
7339 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7340 return err
7341 }
7342 if _, err := cw.WriteString(string("createdAt")); err != nil {
7343 return err
7344 }
7345
7346 if len(t.CreatedAt) > 1000000 {
7347 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7348 }
7349
7350 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7351 return err
7352 }
7353 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7354 return err
7355 }
7356 return nil
7357}
7358
7359func (t *RepoPullComment) UnmarshalCBOR(r io.Reader) (err error) {
7360 *t = RepoPullComment{}
7361
7362 cr := cbg.NewCborReader(r)
7363
7364 maj, extra, err := cr.ReadHeader()
7365 if err != nil {
7366 return err
7367 }
7368 defer func() {
7369 if err == io.EOF {
7370 err = io.ErrUnexpectedEOF
7371 }
7372 }()
7373
7374 if maj != cbg.MajMap {
7375 return fmt.Errorf("cbor input should be of type map")
7376 }
7377
7378 if extra > cbg.MaxLength {
7379 return fmt.Errorf("RepoPullComment: map struct too large (%d)", extra)
7380 }
7381
7382 n := extra
7383
7384 nameBuf := make([]byte, 9)
7385 for i := uint64(0); i < n; i++ {
7386 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7387 if err != nil {
7388 return err
7389 }
7390
7391 if !ok {
7392 // Field doesn't exist on this type, so ignore it
7393 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7394 return err
7395 }
7396 continue
7397 }
7398
7399 switch string(nameBuf[:nameLen]) {
7400 // t.Body (string) (string)
7401 case "body":
7402
7403 {
7404 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7405 if err != nil {
7406 return err
7407 }
7408
7409 t.Body = string(sval)
7410 }
7411 // t.Pull (string) (string)
7412 case "pull":
7413
7414 {
7415 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7416 if err != nil {
7417 return err
7418 }
7419
7420 t.Pull = string(sval)
7421 }
7422 // t.LexiconTypeID (string) (string)
7423 case "$type":
7424
7425 {
7426 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7427 if err != nil {
7428 return err
7429 }
7430
7431 t.LexiconTypeID = string(sval)
7432 }
7433 // t.CreatedAt (string) (string)
7434 case "createdAt":
7435
7436 {
7437 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7438 if err != nil {
7439 return err
7440 }
7441
7442 t.CreatedAt = string(sval)
7443 }
7444
7445 default:
7446 // Field doesn't exist on this type, so ignore it
7447 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7448 return err
7449 }
7450 }
7451 }
7452
7453 return nil
7454}
7455func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error {
7456 if t == nil {
7457 _, err := w.Write(cbg.CborNull)
7458 return err
7459 }
7460
7461 cw := cbg.NewCborWriter(w)
7462 fieldCount := 3
7463
7464 if t.Repo == nil {
7465 fieldCount--
7466 }
7467
7468 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7469 return err
7470 }
7471
7472 // t.Sha (string) (string)
7473 if len("sha") > 1000000 {
7474 return xerrors.Errorf("Value in field \"sha\" was too long")
7475 }
7476
7477 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sha"))); err != nil {
7478 return err
7479 }
7480 if _, err := cw.WriteString(string("sha")); err != nil {
7481 return err
7482 }
7483
7484 if len(t.Sha) > 1000000 {
7485 return xerrors.Errorf("Value in field t.Sha was too long")
7486 }
7487
7488 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Sha))); err != nil {
7489 return err
7490 }
7491 if _, err := cw.WriteString(string(t.Sha)); err != nil {
7492 return err
7493 }
7494
7495 // t.Repo (string) (string)
7496 if t.Repo != nil {
7497
7498 if len("repo") > 1000000 {
7499 return xerrors.Errorf("Value in field \"repo\" was too long")
7500 }
7501
7502 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
7503 return err
7504 }
7505 if _, err := cw.WriteString(string("repo")); err != nil {
7506 return err
7507 }
7508
7509 if t.Repo == nil {
7510 if _, err := cw.Write(cbg.CborNull); err != nil {
7511 return err
7512 }
7513 } else {
7514 if len(*t.Repo) > 1000000 {
7515 return xerrors.Errorf("Value in field t.Repo was too long")
7516 }
7517
7518 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
7519 return err
7520 }
7521 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
7522 return err
7523 }
7524 }
7525 }
7526
7527 // t.Branch (string) (string)
7528 if len("branch") > 1000000 {
7529 return xerrors.Errorf("Value in field \"branch\" was too long")
7530 }
7531
7532 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
7533 return err
7534 }
7535 if _, err := cw.WriteString(string("branch")); err != nil {
7536 return err
7537 }
7538
7539 if len(t.Branch) > 1000000 {
7540 return xerrors.Errorf("Value in field t.Branch was too long")
7541 }
7542
7543 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
7544 return err
7545 }
7546 if _, err := cw.WriteString(string(t.Branch)); err != nil {
7547 return err
7548 }
7549 return nil
7550}
7551
7552func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) {
7553 *t = RepoPull_Source{}
7554
7555 cr := cbg.NewCborReader(r)
7556
7557 maj, extra, err := cr.ReadHeader()
7558 if err != nil {
7559 return err
7560 }
7561 defer func() {
7562 if err == io.EOF {
7563 err = io.ErrUnexpectedEOF
7564 }
7565 }()
7566
7567 if maj != cbg.MajMap {
7568 return fmt.Errorf("cbor input should be of type map")
7569 }
7570
7571 if extra > cbg.MaxLength {
7572 return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra)
7573 }
7574
7575 n := extra
7576
7577 nameBuf := make([]byte, 6)
7578 for i := uint64(0); i < n; i++ {
7579 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7580 if err != nil {
7581 return err
7582 }
7583
7584 if !ok {
7585 // Field doesn't exist on this type, so ignore it
7586 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7587 return err
7588 }
7589 continue
7590 }
7591
7592 switch string(nameBuf[:nameLen]) {
7593 // t.Sha (string) (string)
7594 case "sha":
7595
7596 {
7597 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7598 if err != nil {
7599 return err
7600 }
7601
7602 t.Sha = string(sval)
7603 }
7604 // t.Repo (string) (string)
7605 case "repo":
7606
7607 {
7608 b, err := cr.ReadByte()
7609 if err != nil {
7610 return err
7611 }
7612 if b != cbg.CborNull[0] {
7613 if err := cr.UnreadByte(); err != nil {
7614 return err
7615 }
7616
7617 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7618 if err != nil {
7619 return err
7620 }
7621
7622 t.Repo = (*string)(&sval)
7623 }
7624 }
7625 // t.Branch (string) (string)
7626 case "branch":
7627
7628 {
7629 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7630 if err != nil {
7631 return err
7632 }
7633
7634 t.Branch = string(sval)
7635 }
7636
7637 default:
7638 // Field doesn't exist on this type, so ignore it
7639 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7640 return err
7641 }
7642 }
7643 }
7644
7645 return nil
7646}
7647func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error {
7648 if t == nil {
7649 _, err := w.Write(cbg.CborNull)
7650 return err
7651 }
7652
7653 cw := cbg.NewCborWriter(w)
7654
7655 if _, err := cw.Write([]byte{163}); err != nil {
7656 return err
7657 }
7658
7659 // t.Pull (string) (string)
7660 if len("pull") > 1000000 {
7661 return xerrors.Errorf("Value in field \"pull\" was too long")
7662 }
7663
7664 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
7665 return err
7666 }
7667 if _, err := cw.WriteString(string("pull")); err != nil {
7668 return err
7669 }
7670
7671 if len(t.Pull) > 1000000 {
7672 return xerrors.Errorf("Value in field t.Pull was too long")
7673 }
7674
7675 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
7676 return err
7677 }
7678 if _, err := cw.WriteString(string(t.Pull)); err != nil {
7679 return err
7680 }
7681
7682 // t.LexiconTypeID (string) (string)
7683 if len("$type") > 1000000 {
7684 return xerrors.Errorf("Value in field \"$type\" was too long")
7685 }
7686
7687 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7688 return err
7689 }
7690 if _, err := cw.WriteString(string("$type")); err != nil {
7691 return err
7692 }
7693
7694 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil {
7695 return err
7696 }
7697 if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil {
7698 return err
7699 }
7700
7701 // t.Status (string) (string)
7702 if len("status") > 1000000 {
7703 return xerrors.Errorf("Value in field \"status\" was too long")
7704 }
7705
7706 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
7707 return err
7708 }
7709 if _, err := cw.WriteString(string("status")); err != nil {
7710 return err
7711 }
7712
7713 if len(t.Status) > 1000000 {
7714 return xerrors.Errorf("Value in field t.Status was too long")
7715 }
7716
7717 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
7718 return err
7719 }
7720 if _, err := cw.WriteString(string(t.Status)); err != nil {
7721 return err
7722 }
7723 return nil
7724}
7725
7726func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) {
7727 *t = RepoPullStatus{}
7728
7729 cr := cbg.NewCborReader(r)
7730
7731 maj, extra, err := cr.ReadHeader()
7732 if err != nil {
7733 return err
7734 }
7735 defer func() {
7736 if err == io.EOF {
7737 err = io.ErrUnexpectedEOF
7738 }
7739 }()
7740
7741 if maj != cbg.MajMap {
7742 return fmt.Errorf("cbor input should be of type map")
7743 }
7744
7745 if extra > cbg.MaxLength {
7746 return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra)
7747 }
7748
7749 n := extra
7750
7751 nameBuf := make([]byte, 6)
7752 for i := uint64(0); i < n; i++ {
7753 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7754 if err != nil {
7755 return err
7756 }
7757
7758 if !ok {
7759 // Field doesn't exist on this type, so ignore it
7760 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7761 return err
7762 }
7763 continue
7764 }
7765
7766 switch string(nameBuf[:nameLen]) {
7767 // t.Pull (string) (string)
7768 case "pull":
7769
7770 {
7771 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7772 if err != nil {
7773 return err
7774 }
7775
7776 t.Pull = string(sval)
7777 }
7778 // t.LexiconTypeID (string) (string)
7779 case "$type":
7780
7781 {
7782 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7783 if err != nil {
7784 return err
7785 }
7786
7787 t.LexiconTypeID = string(sval)
7788 }
7789 // t.Status (string) (string)
7790 case "status":
7791
7792 {
7793 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7794 if err != nil {
7795 return err
7796 }
7797
7798 t.Status = string(sval)
7799 }
7800
7801 default:
7802 // Field doesn't exist on this type, so ignore it
7803 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7804 return err
7805 }
7806 }
7807 }
7808
7809 return nil
7810}
7811func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error {
7812 if t == nil {
7813 _, err := w.Write(cbg.CborNull)
7814 return err
7815 }
7816
7817 cw := cbg.NewCborWriter(w)
7818
7819 if _, err := cw.Write([]byte{162}); err != nil {
7820 return err
7821 }
7822
7823 // t.Repo (string) (string)
7824 if len("repo") > 1000000 {
7825 return xerrors.Errorf("Value in field \"repo\" was too long")
7826 }
7827
7828 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
7829 return err
7830 }
7831 if _, err := cw.WriteString(string("repo")); err != nil {
7832 return err
7833 }
7834
7835 if len(t.Repo) > 1000000 {
7836 return xerrors.Errorf("Value in field t.Repo was too long")
7837 }
7838
7839 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
7840 return err
7841 }
7842 if _, err := cw.WriteString(string(t.Repo)); err != nil {
7843 return err
7844 }
7845
7846 // t.Branch (string) (string)
7847 if len("branch") > 1000000 {
7848 return xerrors.Errorf("Value in field \"branch\" was too long")
7849 }
7850
7851 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
7852 return err
7853 }
7854 if _, err := cw.WriteString(string("branch")); err != nil {
7855 return err
7856 }
7857
7858 if len(t.Branch) > 1000000 {
7859 return xerrors.Errorf("Value in field t.Branch was too long")
7860 }
7861
7862 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
7863 return err
7864 }
7865 if _, err := cw.WriteString(string(t.Branch)); err != nil {
7866 return err
7867 }
7868 return nil
7869}
7870
7871func (t *RepoPull_Target) UnmarshalCBOR(r io.Reader) (err error) {
7872 *t = RepoPull_Target{}
7873
7874 cr := cbg.NewCborReader(r)
7875
7876 maj, extra, err := cr.ReadHeader()
7877 if err != nil {
7878 return err
7879 }
7880 defer func() {
7881 if err == io.EOF {
7882 err = io.ErrUnexpectedEOF
7883 }
7884 }()
7885
7886 if maj != cbg.MajMap {
7887 return fmt.Errorf("cbor input should be of type map")
7888 }
7889
7890 if extra > cbg.MaxLength {
7891 return fmt.Errorf("RepoPull_Target: map struct too large (%d)", extra)
7892 }
7893
7894 n := extra
7895
7896 nameBuf := make([]byte, 6)
7897 for i := uint64(0); i < n; i++ {
7898 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7899 if err != nil {
7900 return err
7901 }
7902
7903 if !ok {
7904 // Field doesn't exist on this type, so ignore it
7905 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7906 return err
7907 }
7908 continue
7909 }
7910
7911 switch string(nameBuf[:nameLen]) {
7912 // t.Repo (string) (string)
7913 case "repo":
7914
7915 {
7916 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7917 if err != nil {
7918 return err
7919 }
7920
7921 t.Repo = string(sval)
7922 }
7923 // t.Branch (string) (string)
7924 case "branch":
7925
7926 {
7927 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7928 if err != nil {
7929 return err
7930 }
7931
7932 t.Branch = string(sval)
7933 }
7934
7935 default:
7936 // Field doesn't exist on this type, so ignore it
7937 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7938 return err
7939 }
7940 }
7941 }
7942
7943 return nil
7944}
7945func (t *Spindle) MarshalCBOR(w io.Writer) error {
7946 if t == nil {
7947 _, err := w.Write(cbg.CborNull)
7948 return err
7949 }
7950
7951 cw := cbg.NewCborWriter(w)
7952
7953 if _, err := cw.Write([]byte{162}); err != nil {
7954 return err
7955 }
7956
7957 // t.LexiconTypeID (string) (string)
7958 if len("$type") > 1000000 {
7959 return xerrors.Errorf("Value in field \"$type\" was too long")
7960 }
7961
7962 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7963 return err
7964 }
7965 if _, err := cw.WriteString(string("$type")); err != nil {
7966 return err
7967 }
7968
7969 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle"))); err != nil {
7970 return err
7971 }
7972 if _, err := cw.WriteString(string("sh.tangled.spindle")); err != nil {
7973 return err
7974 }
7975
7976 // t.CreatedAt (string) (string)
7977 if len("createdAt") > 1000000 {
7978 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7979 }
7980
7981 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7982 return err
7983 }
7984 if _, err := cw.WriteString(string("createdAt")); err != nil {
7985 return err
7986 }
7987
7988 if len(t.CreatedAt) > 1000000 {
7989 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7990 }
7991
7992 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7993 return err
7994 }
7995 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7996 return err
7997 }
7998 return nil
7999}
8000
8001func (t *Spindle) UnmarshalCBOR(r io.Reader) (err error) {
8002 *t = Spindle{}
8003
8004 cr := cbg.NewCborReader(r)
8005
8006 maj, extra, err := cr.ReadHeader()
8007 if err != nil {
8008 return err
8009 }
8010 defer func() {
8011 if err == io.EOF {
8012 err = io.ErrUnexpectedEOF
8013 }
8014 }()
8015
8016 if maj != cbg.MajMap {
8017 return fmt.Errorf("cbor input should be of type map")
8018 }
8019
8020 if extra > cbg.MaxLength {
8021 return fmt.Errorf("Spindle: map struct too large (%d)", extra)
8022 }
8023
8024 n := extra
8025
8026 nameBuf := make([]byte, 9)
8027 for i := uint64(0); i < n; i++ {
8028 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8029 if err != nil {
8030 return err
8031 }
8032
8033 if !ok {
8034 // Field doesn't exist on this type, so ignore it
8035 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8036 return err
8037 }
8038 continue
8039 }
8040
8041 switch string(nameBuf[:nameLen]) {
8042 // t.LexiconTypeID (string) (string)
8043 case "$type":
8044
8045 {
8046 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8047 if err != nil {
8048 return err
8049 }
8050
8051 t.LexiconTypeID = string(sval)
8052 }
8053 // t.CreatedAt (string) (string)
8054 case "createdAt":
8055
8056 {
8057 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8058 if err != nil {
8059 return err
8060 }
8061
8062 t.CreatedAt = string(sval)
8063 }
8064
8065 default:
8066 // Field doesn't exist on this type, so ignore it
8067 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8068 return err
8069 }
8070 }
8071 }
8072
8073 return nil
8074}
8075func (t *SpindleMember) MarshalCBOR(w io.Writer) error {
8076 if t == nil {
8077 _, err := w.Write(cbg.CborNull)
8078 return err
8079 }
8080
8081 cw := cbg.NewCborWriter(w)
8082
8083 if _, err := cw.Write([]byte{164}); err != nil {
8084 return err
8085 }
8086
8087 // t.LexiconTypeID (string) (string)
8088 if len("$type") > 1000000 {
8089 return xerrors.Errorf("Value in field \"$type\" was too long")
8090 }
8091
8092 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8093 return err
8094 }
8095 if _, err := cw.WriteString(string("$type")); err != nil {
8096 return err
8097 }
8098
8099 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle.member"))); err != nil {
8100 return err
8101 }
8102 if _, err := cw.WriteString(string("sh.tangled.spindle.member")); err != nil {
8103 return err
8104 }
8105
8106 // t.Subject (string) (string)
8107 if len("subject") > 1000000 {
8108 return xerrors.Errorf("Value in field \"subject\" was too long")
8109 }
8110
8111 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
8112 return err
8113 }
8114 if _, err := cw.WriteString(string("subject")); err != nil {
8115 return err
8116 }
8117
8118 if len(t.Subject) > 1000000 {
8119 return xerrors.Errorf("Value in field t.Subject was too long")
8120 }
8121
8122 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
8123 return err
8124 }
8125 if _, err := cw.WriteString(string(t.Subject)); err != nil {
8126 return err
8127 }
8128
8129 // t.Instance (string) (string)
8130 if len("instance") > 1000000 {
8131 return xerrors.Errorf("Value in field \"instance\" was too long")
8132 }
8133
8134 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("instance"))); err != nil {
8135 return err
8136 }
8137 if _, err := cw.WriteString(string("instance")); err != nil {
8138 return err
8139 }
8140
8141 if len(t.Instance) > 1000000 {
8142 return xerrors.Errorf("Value in field t.Instance was too long")
8143 }
8144
8145 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Instance))); err != nil {
8146 return err
8147 }
8148 if _, err := cw.WriteString(string(t.Instance)); err != nil {
8149 return err
8150 }
8151
8152 // t.CreatedAt (string) (string)
8153 if len("createdAt") > 1000000 {
8154 return xerrors.Errorf("Value in field \"createdAt\" was too long")
8155 }
8156
8157 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
8158 return err
8159 }
8160 if _, err := cw.WriteString(string("createdAt")); err != nil {
8161 return err
8162 }
8163
8164 if len(t.CreatedAt) > 1000000 {
8165 return xerrors.Errorf("Value in field t.CreatedAt was too long")
8166 }
8167
8168 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
8169 return err
8170 }
8171 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
8172 return err
8173 }
8174 return nil
8175}
8176
8177func (t *SpindleMember) UnmarshalCBOR(r io.Reader) (err error) {
8178 *t = SpindleMember{}
8179
8180 cr := cbg.NewCborReader(r)
8181
8182 maj, extra, err := cr.ReadHeader()
8183 if err != nil {
8184 return err
8185 }
8186 defer func() {
8187 if err == io.EOF {
8188 err = io.ErrUnexpectedEOF
8189 }
8190 }()
8191
8192 if maj != cbg.MajMap {
8193 return fmt.Errorf("cbor input should be of type map")
8194 }
8195
8196 if extra > cbg.MaxLength {
8197 return fmt.Errorf("SpindleMember: map struct too large (%d)", extra)
8198 }
8199
8200 n := extra
8201
8202 nameBuf := make([]byte, 9)
8203 for i := uint64(0); i < n; i++ {
8204 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8205 if err != nil {
8206 return err
8207 }
8208
8209 if !ok {
8210 // Field doesn't exist on this type, so ignore it
8211 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8212 return err
8213 }
8214 continue
8215 }
8216
8217 switch string(nameBuf[:nameLen]) {
8218 // t.LexiconTypeID (string) (string)
8219 case "$type":
8220
8221 {
8222 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8223 if err != nil {
8224 return err
8225 }
8226
8227 t.LexiconTypeID = string(sval)
8228 }
8229 // t.Subject (string) (string)
8230 case "subject":
8231
8232 {
8233 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8234 if err != nil {
8235 return err
8236 }
8237
8238 t.Subject = string(sval)
8239 }
8240 // t.Instance (string) (string)
8241 case "instance":
8242
8243 {
8244 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8245 if err != nil {
8246 return err
8247 }
8248
8249 t.Instance = string(sval)
8250 }
8251 // t.CreatedAt (string) (string)
8252 case "createdAt":
8253
8254 {
8255 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8256 if err != nil {
8257 return err
8258 }
8259
8260 t.CreatedAt = string(sval)
8261 }
8262
8263 default:
8264 // Field doesn't exist on this type, so ignore it
8265 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8266 return err
8267 }
8268 }
8269 }
8270
8271 return nil
8272}
8273func (t *String) MarshalCBOR(w io.Writer) error {
8274 if t == nil {
8275 _, err := w.Write(cbg.CborNull)
8276 return err
8277 }
8278
8279 cw := cbg.NewCborWriter(w)
8280
8281 if _, err := cw.Write([]byte{165}); err != nil {
8282 return err
8283 }
8284
8285 // t.LexiconTypeID (string) (string)
8286 if len("$type") > 1000000 {
8287 return xerrors.Errorf("Value in field \"$type\" was too long")
8288 }
8289
8290 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8291 return err
8292 }
8293 if _, err := cw.WriteString(string("$type")); err != nil {
8294 return err
8295 }
8296
8297 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.string"))); err != nil {
8298 return err
8299 }
8300 if _, err := cw.WriteString(string("sh.tangled.string")); err != nil {
8301 return err
8302 }
8303
8304 // t.Contents (string) (string)
8305 if len("contents") > 1000000 {
8306 return xerrors.Errorf("Value in field \"contents\" was too long")
8307 }
8308
8309 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("contents"))); err != nil {
8310 return err
8311 }
8312 if _, err := cw.WriteString(string("contents")); err != nil {
8313 return err
8314 }
8315
8316 if len(t.Contents) > 1000000 {
8317 return xerrors.Errorf("Value in field t.Contents was too long")
8318 }
8319
8320 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Contents))); err != nil {
8321 return err
8322 }
8323 if _, err := cw.WriteString(string(t.Contents)); err != nil {
8324 return err
8325 }
8326
8327 // t.Filename (string) (string)
8328 if len("filename") > 1000000 {
8329 return xerrors.Errorf("Value in field \"filename\" was too long")
8330 }
8331
8332 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("filename"))); err != nil {
8333 return err
8334 }
8335 if _, err := cw.WriteString(string("filename")); err != nil {
8336 return err
8337 }
8338
8339 if len(t.Filename) > 1000000 {
8340 return xerrors.Errorf("Value in field t.Filename was too long")
8341 }
8342
8343 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Filename))); err != nil {
8344 return err
8345 }
8346 if _, err := cw.WriteString(string(t.Filename)); err != nil {
8347 return err
8348 }
8349
8350 // t.CreatedAt (string) (string)
8351 if len("createdAt") > 1000000 {
8352 return xerrors.Errorf("Value in field \"createdAt\" was too long")
8353 }
8354
8355 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
8356 return err
8357 }
8358 if _, err := cw.WriteString(string("createdAt")); err != nil {
8359 return err
8360 }
8361
8362 if len(t.CreatedAt) > 1000000 {
8363 return xerrors.Errorf("Value in field t.CreatedAt was too long")
8364 }
8365
8366 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
8367 return err
8368 }
8369 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
8370 return err
8371 }
8372
8373 // t.Description (string) (string)
8374 if len("description") > 1000000 {
8375 return xerrors.Errorf("Value in field \"description\" was too long")
8376 }
8377
8378 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
8379 return err
8380 }
8381 if _, err := cw.WriteString(string("description")); err != nil {
8382 return err
8383 }
8384
8385 if len(t.Description) > 1000000 {
8386 return xerrors.Errorf("Value in field t.Description was too long")
8387 }
8388
8389 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil {
8390 return err
8391 }
8392 if _, err := cw.WriteString(string(t.Description)); err != nil {
8393 return err
8394 }
8395 return nil
8396}
8397
8398func (t *String) UnmarshalCBOR(r io.Reader) (err error) {
8399 *t = String{}
8400
8401 cr := cbg.NewCborReader(r)
8402
8403 maj, extra, err := cr.ReadHeader()
8404 if err != nil {
8405 return err
8406 }
8407 defer func() {
8408 if err == io.EOF {
8409 err = io.ErrUnexpectedEOF
8410 }
8411 }()
8412
8413 if maj != cbg.MajMap {
8414 return fmt.Errorf("cbor input should be of type map")
8415 }
8416
8417 if extra > cbg.MaxLength {
8418 return fmt.Errorf("String: map struct too large (%d)", extra)
8419 }
8420
8421 n := extra
8422
8423 nameBuf := make([]byte, 11)
8424 for i := uint64(0); i < n; i++ {
8425 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8426 if err != nil {
8427 return err
8428 }
8429
8430 if !ok {
8431 // Field doesn't exist on this type, so ignore it
8432 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8433 return err
8434 }
8435 continue
8436 }
8437
8438 switch string(nameBuf[:nameLen]) {
8439 // t.LexiconTypeID (string) (string)
8440 case "$type":
8441
8442 {
8443 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8444 if err != nil {
8445 return err
8446 }
8447
8448 t.LexiconTypeID = string(sval)
8449 }
8450 // t.Contents (string) (string)
8451 case "contents":
8452
8453 {
8454 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8455 if err != nil {
8456 return err
8457 }
8458
8459 t.Contents = string(sval)
8460 }
8461 // t.Filename (string) (string)
8462 case "filename":
8463
8464 {
8465 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8466 if err != nil {
8467 return err
8468 }
8469
8470 t.Filename = string(sval)
8471 }
8472 // t.CreatedAt (string) (string)
8473 case "createdAt":
8474
8475 {
8476 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8477 if err != nil {
8478 return err
8479 }
8480
8481 t.CreatedAt = string(sval)
8482 }
8483 // t.Description (string) (string)
8484 case "description":
8485
8486 {
8487 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8488 if err != nil {
8489 return err
8490 }
8491
8492 t.Description = string(sval)
8493 }
8494
8495 default:
8496 // Field doesn't exist on this type, so ignore it
8497 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8498 return err
8499 }
8500 }
8501 }
8502
8503 return nil
8504}