this repo has no description
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) (string)
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) > 1000000 {
2580 return xerrors.Errorf("Value in field t.Scope was too long")
2581 }
2582
2583 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Scope))); err != nil {
2584 return err
2585 }
2586 if _, err := cw.WriteString(string(t.Scope)); err != nil {
2587 return err
2588 }
2589
2590 // t.Multiple (bool) (bool)
2591 if t.Multiple != nil {
2592
2593 if len("multiple") > 1000000 {
2594 return xerrors.Errorf("Value in field \"multiple\" was too long")
2595 }
2596
2597 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("multiple"))); err != nil {
2598 return err
2599 }
2600 if _, err := cw.WriteString(string("multiple")); err != nil {
2601 return err
2602 }
2603
2604 if t.Multiple == nil {
2605 if _, err := cw.Write(cbg.CborNull); err != nil {
2606 return err
2607 }
2608 } else {
2609 if err := cbg.WriteBool(w, *t.Multiple); err != nil {
2610 return err
2611 }
2612 }
2613 }
2614
2615 // t.CreatedAt (string) (string)
2616 if len("createdAt") > 1000000 {
2617 return xerrors.Errorf("Value in field \"createdAt\" was too long")
2618 }
2619
2620 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2621 return err
2622 }
2623 if _, err := cw.WriteString(string("createdAt")); err != nil {
2624 return err
2625 }
2626
2627 if len(t.CreatedAt) > 1000000 {
2628 return xerrors.Errorf("Value in field t.CreatedAt was too long")
2629 }
2630
2631 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2632 return err
2633 }
2634 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2635 return err
2636 }
2637
2638 // t.ValueType (tangled.LabelDefinition_ValueType) (struct)
2639 if len("valueType") > 1000000 {
2640 return xerrors.Errorf("Value in field \"valueType\" was too long")
2641 }
2642
2643 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("valueType"))); err != nil {
2644 return err
2645 }
2646 if _, err := cw.WriteString(string("valueType")); err != nil {
2647 return err
2648 }
2649
2650 if err := t.ValueType.MarshalCBOR(cw); err != nil {
2651 return err
2652 }
2653 return nil
2654}
2655
2656func (t *LabelDefinition) UnmarshalCBOR(r io.Reader) (err error) {
2657 *t = LabelDefinition{}
2658
2659 cr := cbg.NewCborReader(r)
2660
2661 maj, extra, err := cr.ReadHeader()
2662 if err != nil {
2663 return err
2664 }
2665 defer func() {
2666 if err == io.EOF {
2667 err = io.ErrUnexpectedEOF
2668 }
2669 }()
2670
2671 if maj != cbg.MajMap {
2672 return fmt.Errorf("cbor input should be of type map")
2673 }
2674
2675 if extra > cbg.MaxLength {
2676 return fmt.Errorf("LabelDefinition: map struct too large (%d)", extra)
2677 }
2678
2679 n := extra
2680
2681 nameBuf := make([]byte, 9)
2682 for i := uint64(0); i < n; i++ {
2683 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2684 if err != nil {
2685 return err
2686 }
2687
2688 if !ok {
2689 // Field doesn't exist on this type, so ignore it
2690 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2691 return err
2692 }
2693 continue
2694 }
2695
2696 switch string(nameBuf[:nameLen]) {
2697 // t.Name (string) (string)
2698 case "name":
2699
2700 {
2701 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2702 if err != nil {
2703 return err
2704 }
2705
2706 t.Name = string(sval)
2707 }
2708 // t.LexiconTypeID (string) (string)
2709 case "$type":
2710
2711 {
2712 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2713 if err != nil {
2714 return err
2715 }
2716
2717 t.LexiconTypeID = string(sval)
2718 }
2719 // t.Color (string) (string)
2720 case "color":
2721
2722 {
2723 b, err := cr.ReadByte()
2724 if err != nil {
2725 return err
2726 }
2727 if b != cbg.CborNull[0] {
2728 if err := cr.UnreadByte(); err != nil {
2729 return err
2730 }
2731
2732 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2733 if err != nil {
2734 return err
2735 }
2736
2737 t.Color = (*string)(&sval)
2738 }
2739 }
2740 // t.Scope (string) (string)
2741 case "scope":
2742
2743 {
2744 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2745 if err != nil {
2746 return err
2747 }
2748
2749 t.Scope = string(sval)
2750 }
2751 // t.Multiple (bool) (bool)
2752 case "multiple":
2753
2754 {
2755 b, err := cr.ReadByte()
2756 if err != nil {
2757 return err
2758 }
2759 if b != cbg.CborNull[0] {
2760 if err := cr.UnreadByte(); err != nil {
2761 return err
2762 }
2763
2764 maj, extra, err = cr.ReadHeader()
2765 if err != nil {
2766 return err
2767 }
2768 if maj != cbg.MajOther {
2769 return fmt.Errorf("booleans must be major type 7")
2770 }
2771
2772 var val bool
2773 switch extra {
2774 case 20:
2775 val = false
2776 case 21:
2777 val = true
2778 default:
2779 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
2780 }
2781 t.Multiple = &val
2782 }
2783 }
2784 // t.CreatedAt (string) (string)
2785 case "createdAt":
2786
2787 {
2788 sval, err := cbg.ReadStringWithMax(cr, 1000000)
2789 if err != nil {
2790 return err
2791 }
2792
2793 t.CreatedAt = string(sval)
2794 }
2795 // t.ValueType (tangled.LabelDefinition_ValueType) (struct)
2796 case "valueType":
2797
2798 {
2799
2800 b, err := cr.ReadByte()
2801 if err != nil {
2802 return err
2803 }
2804 if b != cbg.CborNull[0] {
2805 if err := cr.UnreadByte(); err != nil {
2806 return err
2807 }
2808 t.ValueType = new(LabelDefinition_ValueType)
2809 if err := t.ValueType.UnmarshalCBOR(cr); err != nil {
2810 return xerrors.Errorf("unmarshaling t.ValueType pointer: %w", err)
2811 }
2812 }
2813
2814 }
2815
2816 default:
2817 // Field doesn't exist on this type, so ignore it
2818 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2819 return err
2820 }
2821 }
2822 }
2823
2824 return nil
2825}
2826func (t *LabelDefinition_ValueType) MarshalCBOR(w io.Writer) error {
2827 if t == nil {
2828 _, err := w.Write(cbg.CborNull)
2829 return err
2830 }
2831
2832 cw := cbg.NewCborWriter(w)
2833 fieldCount := 4
2834
2835 if t.Enum == nil {
2836 fieldCount--
2837 }
2838
2839 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2840 return err
2841 }
2842
2843 // t.Enum ([]string) (slice)
2844 if t.Enum != nil {
2845
2846 if len("enum") > 1000000 {
2847 return xerrors.Errorf("Value in field \"enum\" was too long")
2848 }
2849
2850 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("enum"))); err != nil {
2851 return err
2852 }
2853 if _, err := cw.WriteString(string("enum")); err != nil {
2854 return err
2855 }
2856
2857 if len(t.Enum) > 8192 {
2858 return xerrors.Errorf("Slice value in field t.Enum was too long")
2859 }
2860
2861 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Enum))); err != nil {
2862 return err
2863 }
2864 for _, v := range t.Enum {
2865 if len(v) > 1000000 {
2866 return xerrors.Errorf("Value in field v was too long")
2867 }
2868
2869 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
2870 return err
2871 }
2872 if _, err := cw.WriteString(string(v)); err != nil {
2873 return err
2874 }
2875
2876 }
2877 }
2878
2879 // t.Type (string) (string)
2880 if len("type") > 1000000 {
2881 return xerrors.Errorf("Value in field \"type\" was too long")
2882 }
2883
2884 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("type"))); err != nil {
2885 return err
2886 }
2887 if _, err := cw.WriteString(string("type")); err != nil {
2888 return err
2889 }
2890
2891 if len(t.Type) > 1000000 {
2892 return xerrors.Errorf("Value in field t.Type was too long")
2893 }
2894
2895 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Type))); err != nil {
2896 return err
2897 }
2898 if _, err := cw.WriteString(string(t.Type)); err != nil {
2899 return err
2900 }
2901
2902 // t.LexiconTypeID (string) (string)
2903 if len("$type") > 1000000 {
2904 return xerrors.Errorf("Value in field \"$type\" was too long")
2905 }
2906
2907 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2908 return err
2909 }
2910 if _, err := cw.WriteString(string("$type")); err != nil {
2911 return err
2912 }
2913
2914 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.definition"))); err != nil {
2915 return err
2916 }
2917 if _, err := cw.WriteString(string("sh.tangled.label.definition")); err != nil {
2918 return err
2919 }
2920
2921 // t.Format (string) (string)
2922 if len("format") > 1000000 {
2923 return xerrors.Errorf("Value in field \"format\" was too long")
2924 }
2925
2926 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("format"))); err != nil {
2927 return err
2928 }
2929 if _, err := cw.WriteString(string("format")); err != nil {
2930 return err
2931 }
2932
2933 if len(t.Format) > 1000000 {
2934 return xerrors.Errorf("Value in field t.Format was too long")
2935 }
2936
2937 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Format))); err != nil {
2938 return err
2939 }
2940 if _, err := cw.WriteString(string(t.Format)); err != nil {
2941 return err
2942 }
2943 return nil
2944}
2945
2946func (t *LabelDefinition_ValueType) UnmarshalCBOR(r io.Reader) (err error) {
2947 *t = LabelDefinition_ValueType{}
2948
2949 cr := cbg.NewCborReader(r)
2950
2951 maj, extra, err := cr.ReadHeader()
2952 if err != nil {
2953 return err
2954 }
2955 defer func() {
2956 if err == io.EOF {
2957 err = io.ErrUnexpectedEOF
2958 }
2959 }()
2960
2961 if maj != cbg.MajMap {
2962 return fmt.Errorf("cbor input should be of type map")
2963 }
2964
2965 if extra > cbg.MaxLength {
2966 return fmt.Errorf("LabelDefinition_ValueType: map struct too large (%d)", extra)
2967 }
2968
2969 n := extra
2970
2971 nameBuf := make([]byte, 6)
2972 for i := uint64(0); i < n; i++ {
2973 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2974 if err != nil {
2975 return err
2976 }
2977
2978 if !ok {
2979 // Field doesn't exist on this type, so ignore it
2980 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2981 return err
2982 }
2983 continue
2984 }
2985
2986 switch string(nameBuf[:nameLen]) {
2987 // t.Enum ([]string) (slice)
2988 case "enum":
2989
2990 maj, extra, err = cr.ReadHeader()
2991 if err != nil {
2992 return err
2993 }
2994
2995 if extra > 8192 {
2996 return fmt.Errorf("t.Enum: array too large (%d)", extra)
2997 }
2998
2999 if maj != cbg.MajArray {
3000 return fmt.Errorf("expected cbor array")
3001 }
3002
3003 if extra > 0 {
3004 t.Enum = make([]string, extra)
3005 }
3006
3007 for i := 0; i < int(extra); i++ {
3008 {
3009 var maj byte
3010 var extra uint64
3011 var err error
3012 _ = maj
3013 _ = extra
3014 _ = err
3015
3016 {
3017 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3018 if err != nil {
3019 return err
3020 }
3021
3022 t.Enum[i] = string(sval)
3023 }
3024
3025 }
3026 }
3027 // t.Type (string) (string)
3028 case "type":
3029
3030 {
3031 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3032 if err != nil {
3033 return err
3034 }
3035
3036 t.Type = string(sval)
3037 }
3038 // t.LexiconTypeID (string) (string)
3039 case "$type":
3040
3041 {
3042 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3043 if err != nil {
3044 return err
3045 }
3046
3047 t.LexiconTypeID = string(sval)
3048 }
3049 // t.Format (string) (string)
3050 case "format":
3051
3052 {
3053 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3054 if err != nil {
3055 return err
3056 }
3057
3058 t.Format = string(sval)
3059 }
3060
3061 default:
3062 // Field doesn't exist on this type, so ignore it
3063 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3064 return err
3065 }
3066 }
3067 }
3068
3069 return nil
3070}
3071func (t *Pipeline) MarshalCBOR(w io.Writer) error {
3072 if t == nil {
3073 _, err := w.Write(cbg.CborNull)
3074 return err
3075 }
3076
3077 cw := cbg.NewCborWriter(w)
3078
3079 if _, err := cw.Write([]byte{163}); err != nil {
3080 return err
3081 }
3082
3083 // t.LexiconTypeID (string) (string)
3084 if len("$type") > 1000000 {
3085 return xerrors.Errorf("Value in field \"$type\" was too long")
3086 }
3087
3088 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3089 return err
3090 }
3091 if _, err := cw.WriteString(string("$type")); err != nil {
3092 return err
3093 }
3094
3095 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil {
3096 return err
3097 }
3098 if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil {
3099 return err
3100 }
3101
3102 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
3103 if len("workflows") > 1000000 {
3104 return xerrors.Errorf("Value in field \"workflows\" was too long")
3105 }
3106
3107 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil {
3108 return err
3109 }
3110 if _, err := cw.WriteString(string("workflows")); err != nil {
3111 return err
3112 }
3113
3114 if len(t.Workflows) > 8192 {
3115 return xerrors.Errorf("Slice value in field t.Workflows was too long")
3116 }
3117
3118 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil {
3119 return err
3120 }
3121 for _, v := range t.Workflows {
3122 if err := v.MarshalCBOR(cw); err != nil {
3123 return err
3124 }
3125
3126 }
3127
3128 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
3129 if len("triggerMetadata") > 1000000 {
3130 return xerrors.Errorf("Value in field \"triggerMetadata\" was too long")
3131 }
3132
3133 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil {
3134 return err
3135 }
3136 if _, err := cw.WriteString(string("triggerMetadata")); err != nil {
3137 return err
3138 }
3139
3140 if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil {
3141 return err
3142 }
3143 return nil
3144}
3145
3146func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) {
3147 *t = Pipeline{}
3148
3149 cr := cbg.NewCborReader(r)
3150
3151 maj, extra, err := cr.ReadHeader()
3152 if err != nil {
3153 return err
3154 }
3155 defer func() {
3156 if err == io.EOF {
3157 err = io.ErrUnexpectedEOF
3158 }
3159 }()
3160
3161 if maj != cbg.MajMap {
3162 return fmt.Errorf("cbor input should be of type map")
3163 }
3164
3165 if extra > cbg.MaxLength {
3166 return fmt.Errorf("Pipeline: map struct too large (%d)", extra)
3167 }
3168
3169 n := extra
3170
3171 nameBuf := make([]byte, 15)
3172 for i := uint64(0); i < n; i++ {
3173 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3174 if err != nil {
3175 return err
3176 }
3177
3178 if !ok {
3179 // Field doesn't exist on this type, so ignore it
3180 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3181 return err
3182 }
3183 continue
3184 }
3185
3186 switch string(nameBuf[:nameLen]) {
3187 // t.LexiconTypeID (string) (string)
3188 case "$type":
3189
3190 {
3191 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3192 if err != nil {
3193 return err
3194 }
3195
3196 t.LexiconTypeID = string(sval)
3197 }
3198 // t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
3199 case "workflows":
3200
3201 maj, extra, err = cr.ReadHeader()
3202 if err != nil {
3203 return err
3204 }
3205
3206 if extra > 8192 {
3207 return fmt.Errorf("t.Workflows: array too large (%d)", extra)
3208 }
3209
3210 if maj != cbg.MajArray {
3211 return fmt.Errorf("expected cbor array")
3212 }
3213
3214 if extra > 0 {
3215 t.Workflows = make([]*Pipeline_Workflow, extra)
3216 }
3217
3218 for i := 0; i < int(extra); i++ {
3219 {
3220 var maj byte
3221 var extra uint64
3222 var err error
3223 _ = maj
3224 _ = extra
3225 _ = err
3226
3227 {
3228
3229 b, err := cr.ReadByte()
3230 if err != nil {
3231 return err
3232 }
3233 if b != cbg.CborNull[0] {
3234 if err := cr.UnreadByte(); err != nil {
3235 return err
3236 }
3237 t.Workflows[i] = new(Pipeline_Workflow)
3238 if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil {
3239 return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err)
3240 }
3241 }
3242
3243 }
3244
3245 }
3246 }
3247 // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
3248 case "triggerMetadata":
3249
3250 {
3251
3252 b, err := cr.ReadByte()
3253 if err != nil {
3254 return err
3255 }
3256 if b != cbg.CborNull[0] {
3257 if err := cr.UnreadByte(); err != nil {
3258 return err
3259 }
3260 t.TriggerMetadata = new(Pipeline_TriggerMetadata)
3261 if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil {
3262 return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err)
3263 }
3264 }
3265
3266 }
3267
3268 default:
3269 // Field doesn't exist on this type, so ignore it
3270 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3271 return err
3272 }
3273 }
3274 }
3275
3276 return nil
3277}
3278func (t *Pipeline_CloneOpts) MarshalCBOR(w io.Writer) error {
3279 if t == nil {
3280 _, err := w.Write(cbg.CborNull)
3281 return err
3282 }
3283
3284 cw := cbg.NewCborWriter(w)
3285
3286 if _, err := cw.Write([]byte{163}); err != nil {
3287 return err
3288 }
3289
3290 // t.Skip (bool) (bool)
3291 if len("skip") > 1000000 {
3292 return xerrors.Errorf("Value in field \"skip\" was too long")
3293 }
3294
3295 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("skip"))); err != nil {
3296 return err
3297 }
3298 if _, err := cw.WriteString(string("skip")); err != nil {
3299 return err
3300 }
3301
3302 if err := cbg.WriteBool(w, t.Skip); err != nil {
3303 return err
3304 }
3305
3306 // t.Depth (int64) (int64)
3307 if len("depth") > 1000000 {
3308 return xerrors.Errorf("Value in field \"depth\" was too long")
3309 }
3310
3311 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("depth"))); err != nil {
3312 return err
3313 }
3314 if _, err := cw.WriteString(string("depth")); err != nil {
3315 return err
3316 }
3317
3318 if t.Depth >= 0 {
3319 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Depth)); err != nil {
3320 return err
3321 }
3322 } else {
3323 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Depth-1)); err != nil {
3324 return err
3325 }
3326 }
3327
3328 // t.Submodules (bool) (bool)
3329 if len("submodules") > 1000000 {
3330 return xerrors.Errorf("Value in field \"submodules\" was too long")
3331 }
3332
3333 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("submodules"))); err != nil {
3334 return err
3335 }
3336 if _, err := cw.WriteString(string("submodules")); err != nil {
3337 return err
3338 }
3339
3340 if err := cbg.WriteBool(w, t.Submodules); err != nil {
3341 return err
3342 }
3343 return nil
3344}
3345
3346func (t *Pipeline_CloneOpts) UnmarshalCBOR(r io.Reader) (err error) {
3347 *t = Pipeline_CloneOpts{}
3348
3349 cr := cbg.NewCborReader(r)
3350
3351 maj, extra, err := cr.ReadHeader()
3352 if err != nil {
3353 return err
3354 }
3355 defer func() {
3356 if err == io.EOF {
3357 err = io.ErrUnexpectedEOF
3358 }
3359 }()
3360
3361 if maj != cbg.MajMap {
3362 return fmt.Errorf("cbor input should be of type map")
3363 }
3364
3365 if extra > cbg.MaxLength {
3366 return fmt.Errorf("Pipeline_CloneOpts: map struct too large (%d)", extra)
3367 }
3368
3369 n := extra
3370
3371 nameBuf := make([]byte, 10)
3372 for i := uint64(0); i < n; i++ {
3373 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3374 if err != nil {
3375 return err
3376 }
3377
3378 if !ok {
3379 // Field doesn't exist on this type, so ignore it
3380 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3381 return err
3382 }
3383 continue
3384 }
3385
3386 switch string(nameBuf[:nameLen]) {
3387 // t.Skip (bool) (bool)
3388 case "skip":
3389
3390 maj, extra, err = cr.ReadHeader()
3391 if err != nil {
3392 return err
3393 }
3394 if maj != cbg.MajOther {
3395 return fmt.Errorf("booleans must be major type 7")
3396 }
3397 switch extra {
3398 case 20:
3399 t.Skip = false
3400 case 21:
3401 t.Skip = true
3402 default:
3403 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
3404 }
3405 // t.Depth (int64) (int64)
3406 case "depth":
3407 {
3408 maj, extra, err := cr.ReadHeader()
3409 if err != nil {
3410 return err
3411 }
3412 var extraI int64
3413 switch maj {
3414 case cbg.MajUnsignedInt:
3415 extraI = int64(extra)
3416 if extraI < 0 {
3417 return fmt.Errorf("int64 positive overflow")
3418 }
3419 case cbg.MajNegativeInt:
3420 extraI = int64(extra)
3421 if extraI < 0 {
3422 return fmt.Errorf("int64 negative overflow")
3423 }
3424 extraI = -1 - extraI
3425 default:
3426 return fmt.Errorf("wrong type for int64 field: %d", maj)
3427 }
3428
3429 t.Depth = int64(extraI)
3430 }
3431 // t.Submodules (bool) (bool)
3432 case "submodules":
3433
3434 maj, extra, err = cr.ReadHeader()
3435 if err != nil {
3436 return err
3437 }
3438 if maj != cbg.MajOther {
3439 return fmt.Errorf("booleans must be major type 7")
3440 }
3441 switch extra {
3442 case 20:
3443 t.Submodules = false
3444 case 21:
3445 t.Submodules = true
3446 default:
3447 return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
3448 }
3449
3450 default:
3451 // Field doesn't exist on this type, so ignore it
3452 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3453 return err
3454 }
3455 }
3456 }
3457
3458 return nil
3459}
3460func (t *Pipeline_ManualTriggerData) MarshalCBOR(w io.Writer) error {
3461 if t == nil {
3462 _, err := w.Write(cbg.CborNull)
3463 return err
3464 }
3465
3466 cw := cbg.NewCborWriter(w)
3467 fieldCount := 1
3468
3469 if t.Inputs == nil {
3470 fieldCount--
3471 }
3472
3473 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3474 return err
3475 }
3476
3477 // t.Inputs ([]*tangled.Pipeline_Pair) (slice)
3478 if t.Inputs != nil {
3479
3480 if len("inputs") > 1000000 {
3481 return xerrors.Errorf("Value in field \"inputs\" was too long")
3482 }
3483
3484 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
3485 return err
3486 }
3487 if _, err := cw.WriteString(string("inputs")); err != nil {
3488 return err
3489 }
3490
3491 if len(t.Inputs) > 8192 {
3492 return xerrors.Errorf("Slice value in field t.Inputs was too long")
3493 }
3494
3495 if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
3496 return err
3497 }
3498 for _, v := range t.Inputs {
3499 if err := v.MarshalCBOR(cw); err != nil {
3500 return err
3501 }
3502
3503 }
3504 }
3505 return nil
3506}
3507
3508func (t *Pipeline_ManualTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
3509 *t = Pipeline_ManualTriggerData{}
3510
3511 cr := cbg.NewCborReader(r)
3512
3513 maj, extra, err := cr.ReadHeader()
3514 if err != nil {
3515 return err
3516 }
3517 defer func() {
3518 if err == io.EOF {
3519 err = io.ErrUnexpectedEOF
3520 }
3521 }()
3522
3523 if maj != cbg.MajMap {
3524 return fmt.Errorf("cbor input should be of type map")
3525 }
3526
3527 if extra > cbg.MaxLength {
3528 return fmt.Errorf("Pipeline_ManualTriggerData: map struct too large (%d)", extra)
3529 }
3530
3531 n := extra
3532
3533 nameBuf := make([]byte, 6)
3534 for i := uint64(0); i < n; i++ {
3535 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3536 if err != nil {
3537 return err
3538 }
3539
3540 if !ok {
3541 // Field doesn't exist on this type, so ignore it
3542 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3543 return err
3544 }
3545 continue
3546 }
3547
3548 switch string(nameBuf[:nameLen]) {
3549 // t.Inputs ([]*tangled.Pipeline_Pair) (slice)
3550 case "inputs":
3551
3552 maj, extra, err = cr.ReadHeader()
3553 if err != nil {
3554 return err
3555 }
3556
3557 if extra > 8192 {
3558 return fmt.Errorf("t.Inputs: array too large (%d)", extra)
3559 }
3560
3561 if maj != cbg.MajArray {
3562 return fmt.Errorf("expected cbor array")
3563 }
3564
3565 if extra > 0 {
3566 t.Inputs = make([]*Pipeline_Pair, extra)
3567 }
3568
3569 for i := 0; i < int(extra); i++ {
3570 {
3571 var maj byte
3572 var extra uint64
3573 var err error
3574 _ = maj
3575 _ = extra
3576 _ = err
3577
3578 {
3579
3580 b, err := cr.ReadByte()
3581 if err != nil {
3582 return err
3583 }
3584 if b != cbg.CborNull[0] {
3585 if err := cr.UnreadByte(); err != nil {
3586 return err
3587 }
3588 t.Inputs[i] = new(Pipeline_Pair)
3589 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
3590 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
3591 }
3592 }
3593
3594 }
3595
3596 }
3597 }
3598
3599 default:
3600 // Field doesn't exist on this type, so ignore it
3601 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3602 return err
3603 }
3604 }
3605 }
3606
3607 return nil
3608}
3609func (t *Pipeline_Pair) MarshalCBOR(w io.Writer) error {
3610 if t == nil {
3611 _, err := w.Write(cbg.CborNull)
3612 return err
3613 }
3614
3615 cw := cbg.NewCborWriter(w)
3616
3617 if _, err := cw.Write([]byte{162}); err != nil {
3618 return err
3619 }
3620
3621 // t.Key (string) (string)
3622 if len("key") > 1000000 {
3623 return xerrors.Errorf("Value in field \"key\" was too long")
3624 }
3625
3626 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
3627 return err
3628 }
3629 if _, err := cw.WriteString(string("key")); err != nil {
3630 return err
3631 }
3632
3633 if len(t.Key) > 1000000 {
3634 return xerrors.Errorf("Value in field t.Key was too long")
3635 }
3636
3637 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
3638 return err
3639 }
3640 if _, err := cw.WriteString(string(t.Key)); err != nil {
3641 return err
3642 }
3643
3644 // t.Value (string) (string)
3645 if len("value") > 1000000 {
3646 return xerrors.Errorf("Value in field \"value\" was too long")
3647 }
3648
3649 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
3650 return err
3651 }
3652 if _, err := cw.WriteString(string("value")); err != nil {
3653 return err
3654 }
3655
3656 if len(t.Value) > 1000000 {
3657 return xerrors.Errorf("Value in field t.Value was too long")
3658 }
3659
3660 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
3661 return err
3662 }
3663 if _, err := cw.WriteString(string(t.Value)); err != nil {
3664 return err
3665 }
3666 return nil
3667}
3668
3669func (t *Pipeline_Pair) UnmarshalCBOR(r io.Reader) (err error) {
3670 *t = Pipeline_Pair{}
3671
3672 cr := cbg.NewCborReader(r)
3673
3674 maj, extra, err := cr.ReadHeader()
3675 if err != nil {
3676 return err
3677 }
3678 defer func() {
3679 if err == io.EOF {
3680 err = io.ErrUnexpectedEOF
3681 }
3682 }()
3683
3684 if maj != cbg.MajMap {
3685 return fmt.Errorf("cbor input should be of type map")
3686 }
3687
3688 if extra > cbg.MaxLength {
3689 return fmt.Errorf("Pipeline_Pair: map struct too large (%d)", extra)
3690 }
3691
3692 n := extra
3693
3694 nameBuf := make([]byte, 5)
3695 for i := uint64(0); i < n; i++ {
3696 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3697 if err != nil {
3698 return err
3699 }
3700
3701 if !ok {
3702 // Field doesn't exist on this type, so ignore it
3703 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3704 return err
3705 }
3706 continue
3707 }
3708
3709 switch string(nameBuf[:nameLen]) {
3710 // t.Key (string) (string)
3711 case "key":
3712
3713 {
3714 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3715 if err != nil {
3716 return err
3717 }
3718
3719 t.Key = string(sval)
3720 }
3721 // t.Value (string) (string)
3722 case "value":
3723
3724 {
3725 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3726 if err != nil {
3727 return err
3728 }
3729
3730 t.Value = string(sval)
3731 }
3732
3733 default:
3734 // Field doesn't exist on this type, so ignore it
3735 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3736 return err
3737 }
3738 }
3739 }
3740
3741 return nil
3742}
3743func (t *Pipeline_PullRequestTriggerData) MarshalCBOR(w io.Writer) error {
3744 if t == nil {
3745 _, err := w.Write(cbg.CborNull)
3746 return err
3747 }
3748
3749 cw := cbg.NewCborWriter(w)
3750
3751 if _, err := cw.Write([]byte{164}); err != nil {
3752 return err
3753 }
3754
3755 // t.Action (string) (string)
3756 if len("action") > 1000000 {
3757 return xerrors.Errorf("Value in field \"action\" was too long")
3758 }
3759
3760 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("action"))); err != nil {
3761 return err
3762 }
3763 if _, err := cw.WriteString(string("action")); err != nil {
3764 return err
3765 }
3766
3767 if len(t.Action) > 1000000 {
3768 return xerrors.Errorf("Value in field t.Action was too long")
3769 }
3770
3771 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Action))); err != nil {
3772 return err
3773 }
3774 if _, err := cw.WriteString(string(t.Action)); err != nil {
3775 return err
3776 }
3777
3778 // t.SourceSha (string) (string)
3779 if len("sourceSha") > 1000000 {
3780 return xerrors.Errorf("Value in field \"sourceSha\" was too long")
3781 }
3782
3783 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceSha"))); err != nil {
3784 return err
3785 }
3786 if _, err := cw.WriteString(string("sourceSha")); err != nil {
3787 return err
3788 }
3789
3790 if len(t.SourceSha) > 1000000 {
3791 return xerrors.Errorf("Value in field t.SourceSha was too long")
3792 }
3793
3794 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceSha))); err != nil {
3795 return err
3796 }
3797 if _, err := cw.WriteString(string(t.SourceSha)); err != nil {
3798 return err
3799 }
3800
3801 // t.SourceBranch (string) (string)
3802 if len("sourceBranch") > 1000000 {
3803 return xerrors.Errorf("Value in field \"sourceBranch\" was too long")
3804 }
3805
3806 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceBranch"))); err != nil {
3807 return err
3808 }
3809 if _, err := cw.WriteString(string("sourceBranch")); err != nil {
3810 return err
3811 }
3812
3813 if len(t.SourceBranch) > 1000000 {
3814 return xerrors.Errorf("Value in field t.SourceBranch was too long")
3815 }
3816
3817 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceBranch))); err != nil {
3818 return err
3819 }
3820 if _, err := cw.WriteString(string(t.SourceBranch)); err != nil {
3821 return err
3822 }
3823
3824 // t.TargetBranch (string) (string)
3825 if len("targetBranch") > 1000000 {
3826 return xerrors.Errorf("Value in field \"targetBranch\" was too long")
3827 }
3828
3829 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil {
3830 return err
3831 }
3832 if _, err := cw.WriteString(string("targetBranch")); err != nil {
3833 return err
3834 }
3835
3836 if len(t.TargetBranch) > 1000000 {
3837 return xerrors.Errorf("Value in field t.TargetBranch was too long")
3838 }
3839
3840 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil {
3841 return err
3842 }
3843 if _, err := cw.WriteString(string(t.TargetBranch)); err != nil {
3844 return err
3845 }
3846 return nil
3847}
3848
3849func (t *Pipeline_PullRequestTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
3850 *t = Pipeline_PullRequestTriggerData{}
3851
3852 cr := cbg.NewCborReader(r)
3853
3854 maj, extra, err := cr.ReadHeader()
3855 if err != nil {
3856 return err
3857 }
3858 defer func() {
3859 if err == io.EOF {
3860 err = io.ErrUnexpectedEOF
3861 }
3862 }()
3863
3864 if maj != cbg.MajMap {
3865 return fmt.Errorf("cbor input should be of type map")
3866 }
3867
3868 if extra > cbg.MaxLength {
3869 return fmt.Errorf("Pipeline_PullRequestTriggerData: map struct too large (%d)", extra)
3870 }
3871
3872 n := extra
3873
3874 nameBuf := make([]byte, 12)
3875 for i := uint64(0); i < n; i++ {
3876 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3877 if err != nil {
3878 return err
3879 }
3880
3881 if !ok {
3882 // Field doesn't exist on this type, so ignore it
3883 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3884 return err
3885 }
3886 continue
3887 }
3888
3889 switch string(nameBuf[:nameLen]) {
3890 // t.Action (string) (string)
3891 case "action":
3892
3893 {
3894 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3895 if err != nil {
3896 return err
3897 }
3898
3899 t.Action = string(sval)
3900 }
3901 // t.SourceSha (string) (string)
3902 case "sourceSha":
3903
3904 {
3905 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3906 if err != nil {
3907 return err
3908 }
3909
3910 t.SourceSha = string(sval)
3911 }
3912 // t.SourceBranch (string) (string)
3913 case "sourceBranch":
3914
3915 {
3916 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3917 if err != nil {
3918 return err
3919 }
3920
3921 t.SourceBranch = string(sval)
3922 }
3923 // t.TargetBranch (string) (string)
3924 case "targetBranch":
3925
3926 {
3927 sval, err := cbg.ReadStringWithMax(cr, 1000000)
3928 if err != nil {
3929 return err
3930 }
3931
3932 t.TargetBranch = string(sval)
3933 }
3934
3935 default:
3936 // Field doesn't exist on this type, so ignore it
3937 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3938 return err
3939 }
3940 }
3941 }
3942
3943 return nil
3944}
3945func (t *Pipeline_PushTriggerData) MarshalCBOR(w io.Writer) error {
3946 if t == nil {
3947 _, err := w.Write(cbg.CborNull)
3948 return err
3949 }
3950
3951 cw := cbg.NewCborWriter(w)
3952
3953 if _, err := cw.Write([]byte{163}); err != nil {
3954 return err
3955 }
3956
3957 // t.Ref (string) (string)
3958 if len("ref") > 1000000 {
3959 return xerrors.Errorf("Value in field \"ref\" was too long")
3960 }
3961
3962 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
3963 return err
3964 }
3965 if _, err := cw.WriteString(string("ref")); err != nil {
3966 return err
3967 }
3968
3969 if len(t.Ref) > 1000000 {
3970 return xerrors.Errorf("Value in field t.Ref was too long")
3971 }
3972
3973 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
3974 return err
3975 }
3976 if _, err := cw.WriteString(string(t.Ref)); err != nil {
3977 return err
3978 }
3979
3980 // t.NewSha (string) (string)
3981 if len("newSha") > 1000000 {
3982 return xerrors.Errorf("Value in field \"newSha\" was too long")
3983 }
3984
3985 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
3986 return err
3987 }
3988 if _, err := cw.WriteString(string("newSha")); err != nil {
3989 return err
3990 }
3991
3992 if len(t.NewSha) > 1000000 {
3993 return xerrors.Errorf("Value in field t.NewSha was too long")
3994 }
3995
3996 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
3997 return err
3998 }
3999 if _, err := cw.WriteString(string(t.NewSha)); err != nil {
4000 return err
4001 }
4002
4003 // t.OldSha (string) (string)
4004 if len("oldSha") > 1000000 {
4005 return xerrors.Errorf("Value in field \"oldSha\" was too long")
4006 }
4007
4008 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
4009 return err
4010 }
4011 if _, err := cw.WriteString(string("oldSha")); err != nil {
4012 return err
4013 }
4014
4015 if len(t.OldSha) > 1000000 {
4016 return xerrors.Errorf("Value in field t.OldSha was too long")
4017 }
4018
4019 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
4020 return err
4021 }
4022 if _, err := cw.WriteString(string(t.OldSha)); err != nil {
4023 return err
4024 }
4025 return nil
4026}
4027
4028func (t *Pipeline_PushTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
4029 *t = Pipeline_PushTriggerData{}
4030
4031 cr := cbg.NewCborReader(r)
4032
4033 maj, extra, err := cr.ReadHeader()
4034 if err != nil {
4035 return err
4036 }
4037 defer func() {
4038 if err == io.EOF {
4039 err = io.ErrUnexpectedEOF
4040 }
4041 }()
4042
4043 if maj != cbg.MajMap {
4044 return fmt.Errorf("cbor input should be of type map")
4045 }
4046
4047 if extra > cbg.MaxLength {
4048 return fmt.Errorf("Pipeline_PushTriggerData: map struct too large (%d)", extra)
4049 }
4050
4051 n := extra
4052
4053 nameBuf := make([]byte, 6)
4054 for i := uint64(0); i < n; i++ {
4055 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4056 if err != nil {
4057 return err
4058 }
4059
4060 if !ok {
4061 // Field doesn't exist on this type, so ignore it
4062 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4063 return err
4064 }
4065 continue
4066 }
4067
4068 switch string(nameBuf[:nameLen]) {
4069 // t.Ref (string) (string)
4070 case "ref":
4071
4072 {
4073 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4074 if err != nil {
4075 return err
4076 }
4077
4078 t.Ref = string(sval)
4079 }
4080 // t.NewSha (string) (string)
4081 case "newSha":
4082
4083 {
4084 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4085 if err != nil {
4086 return err
4087 }
4088
4089 t.NewSha = string(sval)
4090 }
4091 // t.OldSha (string) (string)
4092 case "oldSha":
4093
4094 {
4095 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4096 if err != nil {
4097 return err
4098 }
4099
4100 t.OldSha = string(sval)
4101 }
4102
4103 default:
4104 // Field doesn't exist on this type, so ignore it
4105 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4106 return err
4107 }
4108 }
4109 }
4110
4111 return nil
4112}
4113func (t *PipelineStatus) MarshalCBOR(w io.Writer) error {
4114 if t == nil {
4115 _, err := w.Write(cbg.CborNull)
4116 return err
4117 }
4118
4119 cw := cbg.NewCborWriter(w)
4120 fieldCount := 7
4121
4122 if t.Error == nil {
4123 fieldCount--
4124 }
4125
4126 if t.ExitCode == nil {
4127 fieldCount--
4128 }
4129
4130 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4131 return err
4132 }
4133
4134 // t.LexiconTypeID (string) (string)
4135 if len("$type") > 1000000 {
4136 return xerrors.Errorf("Value in field \"$type\" was too long")
4137 }
4138
4139 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
4140 return err
4141 }
4142 if _, err := cw.WriteString(string("$type")); err != nil {
4143 return err
4144 }
4145
4146 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline.status"))); err != nil {
4147 return err
4148 }
4149 if _, err := cw.WriteString(string("sh.tangled.pipeline.status")); err != nil {
4150 return err
4151 }
4152
4153 // t.Error (string) (string)
4154 if t.Error != nil {
4155
4156 if len("error") > 1000000 {
4157 return xerrors.Errorf("Value in field \"error\" was too long")
4158 }
4159
4160 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("error"))); err != nil {
4161 return err
4162 }
4163 if _, err := cw.WriteString(string("error")); err != nil {
4164 return err
4165 }
4166
4167 if t.Error == nil {
4168 if _, err := cw.Write(cbg.CborNull); err != nil {
4169 return err
4170 }
4171 } else {
4172 if len(*t.Error) > 1000000 {
4173 return xerrors.Errorf("Value in field t.Error was too long")
4174 }
4175
4176 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Error))); err != nil {
4177 return err
4178 }
4179 if _, err := cw.WriteString(string(*t.Error)); err != nil {
4180 return err
4181 }
4182 }
4183 }
4184
4185 // t.Status (string) (string)
4186 if len("status") > 1000000 {
4187 return xerrors.Errorf("Value in field \"status\" was too long")
4188 }
4189
4190 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
4191 return err
4192 }
4193 if _, err := cw.WriteString(string("status")); err != nil {
4194 return err
4195 }
4196
4197 if len(t.Status) > 1000000 {
4198 return xerrors.Errorf("Value in field t.Status was too long")
4199 }
4200
4201 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
4202 return err
4203 }
4204 if _, err := cw.WriteString(string(t.Status)); err != nil {
4205 return err
4206 }
4207
4208 // t.ExitCode (int64) (int64)
4209 if t.ExitCode != nil {
4210
4211 if len("exitCode") > 1000000 {
4212 return xerrors.Errorf("Value in field \"exitCode\" was too long")
4213 }
4214
4215 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("exitCode"))); err != nil {
4216 return err
4217 }
4218 if _, err := cw.WriteString(string("exitCode")); err != nil {
4219 return err
4220 }
4221
4222 if t.ExitCode == nil {
4223 if _, err := cw.Write(cbg.CborNull); err != nil {
4224 return err
4225 }
4226 } else {
4227 if *t.ExitCode >= 0 {
4228 if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.ExitCode)); err != nil {
4229 return err
4230 }
4231 } else {
4232 if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.ExitCode-1)); err != nil {
4233 return err
4234 }
4235 }
4236 }
4237
4238 }
4239
4240 // t.Pipeline (string) (string)
4241 if len("pipeline") > 1000000 {
4242 return xerrors.Errorf("Value in field \"pipeline\" was too long")
4243 }
4244
4245 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pipeline"))); err != nil {
4246 return err
4247 }
4248 if _, err := cw.WriteString(string("pipeline")); err != nil {
4249 return err
4250 }
4251
4252 if len(t.Pipeline) > 1000000 {
4253 return xerrors.Errorf("Value in field t.Pipeline was too long")
4254 }
4255
4256 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pipeline))); err != nil {
4257 return err
4258 }
4259 if _, err := cw.WriteString(string(t.Pipeline)); err != nil {
4260 return err
4261 }
4262
4263 // t.Workflow (string) (string)
4264 if len("workflow") > 1000000 {
4265 return xerrors.Errorf("Value in field \"workflow\" was too long")
4266 }
4267
4268 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil {
4269 return err
4270 }
4271 if _, err := cw.WriteString(string("workflow")); err != nil {
4272 return err
4273 }
4274
4275 if len(t.Workflow) > 1000000 {
4276 return xerrors.Errorf("Value in field t.Workflow was too long")
4277 }
4278
4279 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil {
4280 return err
4281 }
4282 if _, err := cw.WriteString(string(t.Workflow)); err != nil {
4283 return err
4284 }
4285
4286 // t.CreatedAt (string) (string)
4287 if len("createdAt") > 1000000 {
4288 return xerrors.Errorf("Value in field \"createdAt\" was too long")
4289 }
4290
4291 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
4292 return err
4293 }
4294 if _, err := cw.WriteString(string("createdAt")); err != nil {
4295 return err
4296 }
4297
4298 if len(t.CreatedAt) > 1000000 {
4299 return xerrors.Errorf("Value in field t.CreatedAt was too long")
4300 }
4301
4302 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
4303 return err
4304 }
4305 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
4306 return err
4307 }
4308 return nil
4309}
4310
4311func (t *PipelineStatus) UnmarshalCBOR(r io.Reader) (err error) {
4312 *t = PipelineStatus{}
4313
4314 cr := cbg.NewCborReader(r)
4315
4316 maj, extra, err := cr.ReadHeader()
4317 if err != nil {
4318 return err
4319 }
4320 defer func() {
4321 if err == io.EOF {
4322 err = io.ErrUnexpectedEOF
4323 }
4324 }()
4325
4326 if maj != cbg.MajMap {
4327 return fmt.Errorf("cbor input should be of type map")
4328 }
4329
4330 if extra > cbg.MaxLength {
4331 return fmt.Errorf("PipelineStatus: map struct too large (%d)", extra)
4332 }
4333
4334 n := extra
4335
4336 nameBuf := make([]byte, 9)
4337 for i := uint64(0); i < n; i++ {
4338 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4339 if err != nil {
4340 return err
4341 }
4342
4343 if !ok {
4344 // Field doesn't exist on this type, so ignore it
4345 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4346 return err
4347 }
4348 continue
4349 }
4350
4351 switch string(nameBuf[:nameLen]) {
4352 // t.LexiconTypeID (string) (string)
4353 case "$type":
4354
4355 {
4356 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4357 if err != nil {
4358 return err
4359 }
4360
4361 t.LexiconTypeID = string(sval)
4362 }
4363 // t.Error (string) (string)
4364 case "error":
4365
4366 {
4367 b, err := cr.ReadByte()
4368 if err != nil {
4369 return err
4370 }
4371 if b != cbg.CborNull[0] {
4372 if err := cr.UnreadByte(); err != nil {
4373 return err
4374 }
4375
4376 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4377 if err != nil {
4378 return err
4379 }
4380
4381 t.Error = (*string)(&sval)
4382 }
4383 }
4384 // t.Status (string) (string)
4385 case "status":
4386
4387 {
4388 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4389 if err != nil {
4390 return err
4391 }
4392
4393 t.Status = string(sval)
4394 }
4395 // t.ExitCode (int64) (int64)
4396 case "exitCode":
4397 {
4398
4399 b, err := cr.ReadByte()
4400 if err != nil {
4401 return err
4402 }
4403 if b != cbg.CborNull[0] {
4404 if err := cr.UnreadByte(); err != nil {
4405 return err
4406 }
4407 maj, extra, err := cr.ReadHeader()
4408 if err != nil {
4409 return err
4410 }
4411 var extraI int64
4412 switch maj {
4413 case cbg.MajUnsignedInt:
4414 extraI = int64(extra)
4415 if extraI < 0 {
4416 return fmt.Errorf("int64 positive overflow")
4417 }
4418 case cbg.MajNegativeInt:
4419 extraI = int64(extra)
4420 if extraI < 0 {
4421 return fmt.Errorf("int64 negative overflow")
4422 }
4423 extraI = -1 - extraI
4424 default:
4425 return fmt.Errorf("wrong type for int64 field: %d", maj)
4426 }
4427
4428 t.ExitCode = (*int64)(&extraI)
4429 }
4430 }
4431 // t.Pipeline (string) (string)
4432 case "pipeline":
4433
4434 {
4435 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4436 if err != nil {
4437 return err
4438 }
4439
4440 t.Pipeline = string(sval)
4441 }
4442 // t.Workflow (string) (string)
4443 case "workflow":
4444
4445 {
4446 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4447 if err != nil {
4448 return err
4449 }
4450
4451 t.Workflow = string(sval)
4452 }
4453 // t.CreatedAt (string) (string)
4454 case "createdAt":
4455
4456 {
4457 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4458 if err != nil {
4459 return err
4460 }
4461
4462 t.CreatedAt = string(sval)
4463 }
4464
4465 default:
4466 // Field doesn't exist on this type, so ignore it
4467 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4468 return err
4469 }
4470 }
4471 }
4472
4473 return nil
4474}
4475func (t *Pipeline_TriggerMetadata) MarshalCBOR(w io.Writer) error {
4476 if t == nil {
4477 _, err := w.Write(cbg.CborNull)
4478 return err
4479 }
4480
4481 cw := cbg.NewCborWriter(w)
4482 fieldCount := 5
4483
4484 if t.Manual == nil {
4485 fieldCount--
4486 }
4487
4488 if t.PullRequest == nil {
4489 fieldCount--
4490 }
4491
4492 if t.Push == nil {
4493 fieldCount--
4494 }
4495
4496 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4497 return err
4498 }
4499
4500 // t.Kind (string) (string)
4501 if len("kind") > 1000000 {
4502 return xerrors.Errorf("Value in field \"kind\" was too long")
4503 }
4504
4505 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("kind"))); err != nil {
4506 return err
4507 }
4508 if _, err := cw.WriteString(string("kind")); err != nil {
4509 return err
4510 }
4511
4512 if len(t.Kind) > 1000000 {
4513 return xerrors.Errorf("Value in field t.Kind was too long")
4514 }
4515
4516 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Kind))); err != nil {
4517 return err
4518 }
4519 if _, err := cw.WriteString(string(t.Kind)); err != nil {
4520 return err
4521 }
4522
4523 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
4524 if t.Push != nil {
4525
4526 if len("push") > 1000000 {
4527 return xerrors.Errorf("Value in field \"push\" was too long")
4528 }
4529
4530 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("push"))); err != nil {
4531 return err
4532 }
4533 if _, err := cw.WriteString(string("push")); err != nil {
4534 return err
4535 }
4536
4537 if err := t.Push.MarshalCBOR(cw); err != nil {
4538 return err
4539 }
4540 }
4541
4542 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
4543 if len("repo") > 1000000 {
4544 return xerrors.Errorf("Value in field \"repo\" was too long")
4545 }
4546
4547 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
4548 return err
4549 }
4550 if _, err := cw.WriteString(string("repo")); err != nil {
4551 return err
4552 }
4553
4554 if err := t.Repo.MarshalCBOR(cw); err != nil {
4555 return err
4556 }
4557
4558 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
4559 if t.Manual != nil {
4560
4561 if len("manual") > 1000000 {
4562 return xerrors.Errorf("Value in field \"manual\" was too long")
4563 }
4564
4565 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("manual"))); err != nil {
4566 return err
4567 }
4568 if _, err := cw.WriteString(string("manual")); err != nil {
4569 return err
4570 }
4571
4572 if err := t.Manual.MarshalCBOR(cw); err != nil {
4573 return err
4574 }
4575 }
4576
4577 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
4578 if t.PullRequest != nil {
4579
4580 if len("pullRequest") > 1000000 {
4581 return xerrors.Errorf("Value in field \"pullRequest\" was too long")
4582 }
4583
4584 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullRequest"))); err != nil {
4585 return err
4586 }
4587 if _, err := cw.WriteString(string("pullRequest")); err != nil {
4588 return err
4589 }
4590
4591 if err := t.PullRequest.MarshalCBOR(cw); err != nil {
4592 return err
4593 }
4594 }
4595 return nil
4596}
4597
4598func (t *Pipeline_TriggerMetadata) UnmarshalCBOR(r io.Reader) (err error) {
4599 *t = Pipeline_TriggerMetadata{}
4600
4601 cr := cbg.NewCborReader(r)
4602
4603 maj, extra, err := cr.ReadHeader()
4604 if err != nil {
4605 return err
4606 }
4607 defer func() {
4608 if err == io.EOF {
4609 err = io.ErrUnexpectedEOF
4610 }
4611 }()
4612
4613 if maj != cbg.MajMap {
4614 return fmt.Errorf("cbor input should be of type map")
4615 }
4616
4617 if extra > cbg.MaxLength {
4618 return fmt.Errorf("Pipeline_TriggerMetadata: map struct too large (%d)", extra)
4619 }
4620
4621 n := extra
4622
4623 nameBuf := make([]byte, 11)
4624 for i := uint64(0); i < n; i++ {
4625 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4626 if err != nil {
4627 return err
4628 }
4629
4630 if !ok {
4631 // Field doesn't exist on this type, so ignore it
4632 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4633 return err
4634 }
4635 continue
4636 }
4637
4638 switch string(nameBuf[:nameLen]) {
4639 // t.Kind (string) (string)
4640 case "kind":
4641
4642 {
4643 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4644 if err != nil {
4645 return err
4646 }
4647
4648 t.Kind = string(sval)
4649 }
4650 // t.Push (tangled.Pipeline_PushTriggerData) (struct)
4651 case "push":
4652
4653 {
4654
4655 b, err := cr.ReadByte()
4656 if err != nil {
4657 return err
4658 }
4659 if b != cbg.CborNull[0] {
4660 if err := cr.UnreadByte(); err != nil {
4661 return err
4662 }
4663 t.Push = new(Pipeline_PushTriggerData)
4664 if err := t.Push.UnmarshalCBOR(cr); err != nil {
4665 return xerrors.Errorf("unmarshaling t.Push pointer: %w", err)
4666 }
4667 }
4668
4669 }
4670 // t.Repo (tangled.Pipeline_TriggerRepo) (struct)
4671 case "repo":
4672
4673 {
4674
4675 b, err := cr.ReadByte()
4676 if err != nil {
4677 return err
4678 }
4679 if b != cbg.CborNull[0] {
4680 if err := cr.UnreadByte(); err != nil {
4681 return err
4682 }
4683 t.Repo = new(Pipeline_TriggerRepo)
4684 if err := t.Repo.UnmarshalCBOR(cr); err != nil {
4685 return xerrors.Errorf("unmarshaling t.Repo pointer: %w", err)
4686 }
4687 }
4688
4689 }
4690 // t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
4691 case "manual":
4692
4693 {
4694
4695 b, err := cr.ReadByte()
4696 if err != nil {
4697 return err
4698 }
4699 if b != cbg.CborNull[0] {
4700 if err := cr.UnreadByte(); err != nil {
4701 return err
4702 }
4703 t.Manual = new(Pipeline_ManualTriggerData)
4704 if err := t.Manual.UnmarshalCBOR(cr); err != nil {
4705 return xerrors.Errorf("unmarshaling t.Manual pointer: %w", err)
4706 }
4707 }
4708
4709 }
4710 // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
4711 case "pullRequest":
4712
4713 {
4714
4715 b, err := cr.ReadByte()
4716 if err != nil {
4717 return err
4718 }
4719 if b != cbg.CborNull[0] {
4720 if err := cr.UnreadByte(); err != nil {
4721 return err
4722 }
4723 t.PullRequest = new(Pipeline_PullRequestTriggerData)
4724 if err := t.PullRequest.UnmarshalCBOR(cr); err != nil {
4725 return xerrors.Errorf("unmarshaling t.PullRequest pointer: %w", err)
4726 }
4727 }
4728
4729 }
4730
4731 default:
4732 // Field doesn't exist on this type, so ignore it
4733 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4734 return err
4735 }
4736 }
4737 }
4738
4739 return nil
4740}
4741func (t *Pipeline_TriggerRepo) MarshalCBOR(w io.Writer) error {
4742 if t == nil {
4743 _, err := w.Write(cbg.CborNull)
4744 return err
4745 }
4746
4747 cw := cbg.NewCborWriter(w)
4748
4749 if _, err := cw.Write([]byte{164}); err != nil {
4750 return err
4751 }
4752
4753 // t.Did (string) (string)
4754 if len("did") > 1000000 {
4755 return xerrors.Errorf("Value in field \"did\" was too long")
4756 }
4757
4758 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil {
4759 return err
4760 }
4761 if _, err := cw.WriteString(string("did")); err != nil {
4762 return err
4763 }
4764
4765 if len(t.Did) > 1000000 {
4766 return xerrors.Errorf("Value in field t.Did was too long")
4767 }
4768
4769 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil {
4770 return err
4771 }
4772 if _, err := cw.WriteString(string(t.Did)); err != nil {
4773 return err
4774 }
4775
4776 // t.Knot (string) (string)
4777 if len("knot") > 1000000 {
4778 return xerrors.Errorf("Value in field \"knot\" was too long")
4779 }
4780
4781 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
4782 return err
4783 }
4784 if _, err := cw.WriteString(string("knot")); err != nil {
4785 return err
4786 }
4787
4788 if len(t.Knot) > 1000000 {
4789 return xerrors.Errorf("Value in field t.Knot was too long")
4790 }
4791
4792 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
4793 return err
4794 }
4795 if _, err := cw.WriteString(string(t.Knot)); err != nil {
4796 return err
4797 }
4798
4799 // t.Repo (string) (string)
4800 if len("repo") > 1000000 {
4801 return xerrors.Errorf("Value in field \"repo\" was too long")
4802 }
4803
4804 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
4805 return err
4806 }
4807 if _, err := cw.WriteString(string("repo")); err != nil {
4808 return err
4809 }
4810
4811 if len(t.Repo) > 1000000 {
4812 return xerrors.Errorf("Value in field t.Repo was too long")
4813 }
4814
4815 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
4816 return err
4817 }
4818 if _, err := cw.WriteString(string(t.Repo)); err != nil {
4819 return err
4820 }
4821
4822 // t.DefaultBranch (string) (string)
4823 if len("defaultBranch") > 1000000 {
4824 return xerrors.Errorf("Value in field \"defaultBranch\" was too long")
4825 }
4826
4827 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("defaultBranch"))); err != nil {
4828 return err
4829 }
4830 if _, err := cw.WriteString(string("defaultBranch")); err != nil {
4831 return err
4832 }
4833
4834 if len(t.DefaultBranch) > 1000000 {
4835 return xerrors.Errorf("Value in field t.DefaultBranch was too long")
4836 }
4837
4838 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.DefaultBranch))); err != nil {
4839 return err
4840 }
4841 if _, err := cw.WriteString(string(t.DefaultBranch)); err != nil {
4842 return err
4843 }
4844 return nil
4845}
4846
4847func (t *Pipeline_TriggerRepo) UnmarshalCBOR(r io.Reader) (err error) {
4848 *t = Pipeline_TriggerRepo{}
4849
4850 cr := cbg.NewCborReader(r)
4851
4852 maj, extra, err := cr.ReadHeader()
4853 if err != nil {
4854 return err
4855 }
4856 defer func() {
4857 if err == io.EOF {
4858 err = io.ErrUnexpectedEOF
4859 }
4860 }()
4861
4862 if maj != cbg.MajMap {
4863 return fmt.Errorf("cbor input should be of type map")
4864 }
4865
4866 if extra > cbg.MaxLength {
4867 return fmt.Errorf("Pipeline_TriggerRepo: map struct too large (%d)", extra)
4868 }
4869
4870 n := extra
4871
4872 nameBuf := make([]byte, 13)
4873 for i := uint64(0); i < n; i++ {
4874 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4875 if err != nil {
4876 return err
4877 }
4878
4879 if !ok {
4880 // Field doesn't exist on this type, so ignore it
4881 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4882 return err
4883 }
4884 continue
4885 }
4886
4887 switch string(nameBuf[:nameLen]) {
4888 // t.Did (string) (string)
4889 case "did":
4890
4891 {
4892 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4893 if err != nil {
4894 return err
4895 }
4896
4897 t.Did = string(sval)
4898 }
4899 // t.Knot (string) (string)
4900 case "knot":
4901
4902 {
4903 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4904 if err != nil {
4905 return err
4906 }
4907
4908 t.Knot = string(sval)
4909 }
4910 // t.Repo (string) (string)
4911 case "repo":
4912
4913 {
4914 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4915 if err != nil {
4916 return err
4917 }
4918
4919 t.Repo = string(sval)
4920 }
4921 // t.DefaultBranch (string) (string)
4922 case "defaultBranch":
4923
4924 {
4925 sval, err := cbg.ReadStringWithMax(cr, 1000000)
4926 if err != nil {
4927 return err
4928 }
4929
4930 t.DefaultBranch = string(sval)
4931 }
4932
4933 default:
4934 // Field doesn't exist on this type, so ignore it
4935 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4936 return err
4937 }
4938 }
4939 }
4940
4941 return nil
4942}
4943func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error {
4944 if t == nil {
4945 _, err := w.Write(cbg.CborNull)
4946 return err
4947 }
4948
4949 cw := cbg.NewCborWriter(w)
4950
4951 if _, err := cw.Write([]byte{164}); err != nil {
4952 return err
4953 }
4954
4955 // t.Raw (string) (string)
4956 if len("raw") > 1000000 {
4957 return xerrors.Errorf("Value in field \"raw\" was too long")
4958 }
4959
4960 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("raw"))); err != nil {
4961 return err
4962 }
4963 if _, err := cw.WriteString(string("raw")); err != nil {
4964 return err
4965 }
4966
4967 if len(t.Raw) > 1000000 {
4968 return xerrors.Errorf("Value in field t.Raw was too long")
4969 }
4970
4971 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Raw))); err != nil {
4972 return err
4973 }
4974 if _, err := cw.WriteString(string(t.Raw)); err != nil {
4975 return err
4976 }
4977
4978 // t.Name (string) (string)
4979 if len("name") > 1000000 {
4980 return xerrors.Errorf("Value in field \"name\" was too long")
4981 }
4982
4983 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
4984 return err
4985 }
4986 if _, err := cw.WriteString(string("name")); err != nil {
4987 return err
4988 }
4989
4990 if len(t.Name) > 1000000 {
4991 return xerrors.Errorf("Value in field t.Name was too long")
4992 }
4993
4994 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
4995 return err
4996 }
4997 if _, err := cw.WriteString(string(t.Name)); err != nil {
4998 return err
4999 }
5000
5001 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
5002 if len("clone") > 1000000 {
5003 return xerrors.Errorf("Value in field \"clone\" was too long")
5004 }
5005
5006 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil {
5007 return err
5008 }
5009 if _, err := cw.WriteString(string("clone")); err != nil {
5010 return err
5011 }
5012
5013 if err := t.Clone.MarshalCBOR(cw); err != nil {
5014 return err
5015 }
5016
5017 // t.Engine (string) (string)
5018 if len("engine") > 1000000 {
5019 return xerrors.Errorf("Value in field \"engine\" was too long")
5020 }
5021
5022 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("engine"))); err != nil {
5023 return err
5024 }
5025 if _, err := cw.WriteString(string("engine")); err != nil {
5026 return err
5027 }
5028
5029 if len(t.Engine) > 1000000 {
5030 return xerrors.Errorf("Value in field t.Engine was too long")
5031 }
5032
5033 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Engine))); err != nil {
5034 return err
5035 }
5036 if _, err := cw.WriteString(string(t.Engine)); err != nil {
5037 return err
5038 }
5039 return nil
5040}
5041
5042func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) {
5043 *t = Pipeline_Workflow{}
5044
5045 cr := cbg.NewCborReader(r)
5046
5047 maj, extra, err := cr.ReadHeader()
5048 if err != nil {
5049 return err
5050 }
5051 defer func() {
5052 if err == io.EOF {
5053 err = io.ErrUnexpectedEOF
5054 }
5055 }()
5056
5057 if maj != cbg.MajMap {
5058 return fmt.Errorf("cbor input should be of type map")
5059 }
5060
5061 if extra > cbg.MaxLength {
5062 return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra)
5063 }
5064
5065 n := extra
5066
5067 nameBuf := make([]byte, 6)
5068 for i := uint64(0); i < n; i++ {
5069 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5070 if err != nil {
5071 return err
5072 }
5073
5074 if !ok {
5075 // Field doesn't exist on this type, so ignore it
5076 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5077 return err
5078 }
5079 continue
5080 }
5081
5082 switch string(nameBuf[:nameLen]) {
5083 // t.Raw (string) (string)
5084 case "raw":
5085
5086 {
5087 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5088 if err != nil {
5089 return err
5090 }
5091
5092 t.Raw = string(sval)
5093 }
5094 // t.Name (string) (string)
5095 case "name":
5096
5097 {
5098 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5099 if err != nil {
5100 return err
5101 }
5102
5103 t.Name = string(sval)
5104 }
5105 // t.Clone (tangled.Pipeline_CloneOpts) (struct)
5106 case "clone":
5107
5108 {
5109
5110 b, err := cr.ReadByte()
5111 if err != nil {
5112 return err
5113 }
5114 if b != cbg.CborNull[0] {
5115 if err := cr.UnreadByte(); err != nil {
5116 return err
5117 }
5118 t.Clone = new(Pipeline_CloneOpts)
5119 if err := t.Clone.UnmarshalCBOR(cr); err != nil {
5120 return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err)
5121 }
5122 }
5123
5124 }
5125 // t.Engine (string) (string)
5126 case "engine":
5127
5128 {
5129 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5130 if err != nil {
5131 return err
5132 }
5133
5134 t.Engine = string(sval)
5135 }
5136
5137 default:
5138 // Field doesn't exist on this type, so ignore it
5139 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5140 return err
5141 }
5142 }
5143 }
5144
5145 return nil
5146}
5147func (t *PublicKey) MarshalCBOR(w io.Writer) error {
5148 if t == nil {
5149 _, err := w.Write(cbg.CborNull)
5150 return err
5151 }
5152
5153 cw := cbg.NewCborWriter(w)
5154
5155 if _, err := cw.Write([]byte{164}); err != nil {
5156 return err
5157 }
5158
5159 // t.Key (string) (string)
5160 if len("key") > 1000000 {
5161 return xerrors.Errorf("Value in field \"key\" was too long")
5162 }
5163
5164 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
5165 return err
5166 }
5167 if _, err := cw.WriteString(string("key")); err != nil {
5168 return err
5169 }
5170
5171 if len(t.Key) > 1000000 {
5172 return xerrors.Errorf("Value in field t.Key was too long")
5173 }
5174
5175 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
5176 return err
5177 }
5178 if _, err := cw.WriteString(string(t.Key)); err != nil {
5179 return err
5180 }
5181
5182 // t.Name (string) (string)
5183 if len("name") > 1000000 {
5184 return xerrors.Errorf("Value in field \"name\" was too long")
5185 }
5186
5187 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5188 return err
5189 }
5190 if _, err := cw.WriteString(string("name")); err != nil {
5191 return err
5192 }
5193
5194 if len(t.Name) > 1000000 {
5195 return xerrors.Errorf("Value in field t.Name was too long")
5196 }
5197
5198 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5199 return err
5200 }
5201 if _, err := cw.WriteString(string(t.Name)); err != nil {
5202 return err
5203 }
5204
5205 // t.LexiconTypeID (string) (string)
5206 if len("$type") > 1000000 {
5207 return xerrors.Errorf("Value in field \"$type\" was too long")
5208 }
5209
5210 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5211 return err
5212 }
5213 if _, err := cw.WriteString(string("$type")); err != nil {
5214 return err
5215 }
5216
5217 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil {
5218 return err
5219 }
5220 if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil {
5221 return err
5222 }
5223
5224 // t.CreatedAt (string) (string)
5225 if len("createdAt") > 1000000 {
5226 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5227 }
5228
5229 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5230 return err
5231 }
5232 if _, err := cw.WriteString(string("createdAt")); err != nil {
5233 return err
5234 }
5235
5236 if len(t.CreatedAt) > 1000000 {
5237 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5238 }
5239
5240 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5241 return err
5242 }
5243 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5244 return err
5245 }
5246 return nil
5247}
5248
5249func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) {
5250 *t = PublicKey{}
5251
5252 cr := cbg.NewCborReader(r)
5253
5254 maj, extra, err := cr.ReadHeader()
5255 if err != nil {
5256 return err
5257 }
5258 defer func() {
5259 if err == io.EOF {
5260 err = io.ErrUnexpectedEOF
5261 }
5262 }()
5263
5264 if maj != cbg.MajMap {
5265 return fmt.Errorf("cbor input should be of type map")
5266 }
5267
5268 if extra > cbg.MaxLength {
5269 return fmt.Errorf("PublicKey: map struct too large (%d)", extra)
5270 }
5271
5272 n := extra
5273
5274 nameBuf := make([]byte, 9)
5275 for i := uint64(0); i < n; i++ {
5276 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5277 if err != nil {
5278 return err
5279 }
5280
5281 if !ok {
5282 // Field doesn't exist on this type, so ignore it
5283 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5284 return err
5285 }
5286 continue
5287 }
5288
5289 switch string(nameBuf[:nameLen]) {
5290 // t.Key (string) (string)
5291 case "key":
5292
5293 {
5294 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5295 if err != nil {
5296 return err
5297 }
5298
5299 t.Key = string(sval)
5300 }
5301 // t.Name (string) (string)
5302 case "name":
5303
5304 {
5305 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5306 if err != nil {
5307 return err
5308 }
5309
5310 t.Name = string(sval)
5311 }
5312 // t.LexiconTypeID (string) (string)
5313 case "$type":
5314
5315 {
5316 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5317 if err != nil {
5318 return err
5319 }
5320
5321 t.LexiconTypeID = string(sval)
5322 }
5323 // t.CreatedAt (string) (string)
5324 case "createdAt":
5325
5326 {
5327 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5328 if err != nil {
5329 return err
5330 }
5331
5332 t.CreatedAt = string(sval)
5333 }
5334
5335 default:
5336 // Field doesn't exist on this type, so ignore it
5337 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5338 return err
5339 }
5340 }
5341 }
5342
5343 return nil
5344}
5345func (t *Repo) MarshalCBOR(w io.Writer) error {
5346 if t == nil {
5347 _, err := w.Write(cbg.CborNull)
5348 return err
5349 }
5350
5351 cw := cbg.NewCborWriter(w)
5352 fieldCount := 8
5353
5354 if t.Description == nil {
5355 fieldCount--
5356 }
5357
5358 if t.Source == nil {
5359 fieldCount--
5360 }
5361
5362 if t.Spindle == nil {
5363 fieldCount--
5364 }
5365
5366 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5367 return err
5368 }
5369
5370 // t.Knot (string) (string)
5371 if len("knot") > 1000000 {
5372 return xerrors.Errorf("Value in field \"knot\" was too long")
5373 }
5374
5375 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
5376 return err
5377 }
5378 if _, err := cw.WriteString(string("knot")); err != nil {
5379 return err
5380 }
5381
5382 if len(t.Knot) > 1000000 {
5383 return xerrors.Errorf("Value in field t.Knot was too long")
5384 }
5385
5386 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
5387 return err
5388 }
5389 if _, err := cw.WriteString(string(t.Knot)); err != nil {
5390 return err
5391 }
5392
5393 // t.Name (string) (string)
5394 if len("name") > 1000000 {
5395 return xerrors.Errorf("Value in field \"name\" was too long")
5396 }
5397
5398 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5399 return err
5400 }
5401 if _, err := cw.WriteString(string("name")); err != nil {
5402 return err
5403 }
5404
5405 if len(t.Name) > 1000000 {
5406 return xerrors.Errorf("Value in field t.Name was too long")
5407 }
5408
5409 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5410 return err
5411 }
5412 if _, err := cw.WriteString(string(t.Name)); err != nil {
5413 return err
5414 }
5415
5416 // t.LexiconTypeID (string) (string)
5417 if len("$type") > 1000000 {
5418 return xerrors.Errorf("Value in field \"$type\" was too long")
5419 }
5420
5421 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5422 return err
5423 }
5424 if _, err := cw.WriteString(string("$type")); err != nil {
5425 return err
5426 }
5427
5428 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil {
5429 return err
5430 }
5431 if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil {
5432 return err
5433 }
5434
5435 // t.Owner (string) (string)
5436 if len("owner") > 1000000 {
5437 return xerrors.Errorf("Value in field \"owner\" was too long")
5438 }
5439
5440 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
5441 return err
5442 }
5443 if _, err := cw.WriteString(string("owner")); err != nil {
5444 return err
5445 }
5446
5447 if len(t.Owner) > 1000000 {
5448 return xerrors.Errorf("Value in field t.Owner was too long")
5449 }
5450
5451 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {
5452 return err
5453 }
5454 if _, err := cw.WriteString(string(t.Owner)); err != nil {
5455 return err
5456 }
5457
5458 // t.Source (string) (string)
5459 if t.Source != nil {
5460
5461 if len("source") > 1000000 {
5462 return xerrors.Errorf("Value in field \"source\" was too long")
5463 }
5464
5465 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
5466 return err
5467 }
5468 if _, err := cw.WriteString(string("source")); err != nil {
5469 return err
5470 }
5471
5472 if t.Source == nil {
5473 if _, err := cw.Write(cbg.CborNull); err != nil {
5474 return err
5475 }
5476 } else {
5477 if len(*t.Source) > 1000000 {
5478 return xerrors.Errorf("Value in field t.Source was too long")
5479 }
5480
5481 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil {
5482 return err
5483 }
5484 if _, err := cw.WriteString(string(*t.Source)); err != nil {
5485 return err
5486 }
5487 }
5488 }
5489
5490 // t.Spindle (string) (string)
5491 if t.Spindle != nil {
5492
5493 if len("spindle") > 1000000 {
5494 return xerrors.Errorf("Value in field \"spindle\" was too long")
5495 }
5496
5497 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("spindle"))); err != nil {
5498 return err
5499 }
5500 if _, err := cw.WriteString(string("spindle")); err != nil {
5501 return err
5502 }
5503
5504 if t.Spindle == nil {
5505 if _, err := cw.Write(cbg.CborNull); err != nil {
5506 return err
5507 }
5508 } else {
5509 if len(*t.Spindle) > 1000000 {
5510 return xerrors.Errorf("Value in field t.Spindle was too long")
5511 }
5512
5513 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Spindle))); err != nil {
5514 return err
5515 }
5516 if _, err := cw.WriteString(string(*t.Spindle)); err != nil {
5517 return err
5518 }
5519 }
5520 }
5521
5522 // t.CreatedAt (string) (string)
5523 if len("createdAt") > 1000000 {
5524 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5525 }
5526
5527 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5528 return err
5529 }
5530 if _, err := cw.WriteString(string("createdAt")); err != nil {
5531 return err
5532 }
5533
5534 if len(t.CreatedAt) > 1000000 {
5535 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5536 }
5537
5538 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5539 return err
5540 }
5541 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5542 return err
5543 }
5544
5545 // t.Description (string) (string)
5546 if t.Description != nil {
5547
5548 if len("description") > 1000000 {
5549 return xerrors.Errorf("Value in field \"description\" was too long")
5550 }
5551
5552 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
5553 return err
5554 }
5555 if _, err := cw.WriteString(string("description")); err != nil {
5556 return err
5557 }
5558
5559 if t.Description == nil {
5560 if _, err := cw.Write(cbg.CborNull); err != nil {
5561 return err
5562 }
5563 } else {
5564 if len(*t.Description) > 1000000 {
5565 return xerrors.Errorf("Value in field t.Description was too long")
5566 }
5567
5568 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
5569 return err
5570 }
5571 if _, err := cw.WriteString(string(*t.Description)); err != nil {
5572 return err
5573 }
5574 }
5575 }
5576 return nil
5577}
5578
5579func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) {
5580 *t = Repo{}
5581
5582 cr := cbg.NewCborReader(r)
5583
5584 maj, extra, err := cr.ReadHeader()
5585 if err != nil {
5586 return err
5587 }
5588 defer func() {
5589 if err == io.EOF {
5590 err = io.ErrUnexpectedEOF
5591 }
5592 }()
5593
5594 if maj != cbg.MajMap {
5595 return fmt.Errorf("cbor input should be of type map")
5596 }
5597
5598 if extra > cbg.MaxLength {
5599 return fmt.Errorf("Repo: map struct too large (%d)", extra)
5600 }
5601
5602 n := extra
5603
5604 nameBuf := make([]byte, 11)
5605 for i := uint64(0); i < n; i++ {
5606 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5607 if err != nil {
5608 return err
5609 }
5610
5611 if !ok {
5612 // Field doesn't exist on this type, so ignore it
5613 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5614 return err
5615 }
5616 continue
5617 }
5618
5619 switch string(nameBuf[:nameLen]) {
5620 // t.Knot (string) (string)
5621 case "knot":
5622
5623 {
5624 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5625 if err != nil {
5626 return err
5627 }
5628
5629 t.Knot = string(sval)
5630 }
5631 // t.Name (string) (string)
5632 case "name":
5633
5634 {
5635 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5636 if err != nil {
5637 return err
5638 }
5639
5640 t.Name = string(sval)
5641 }
5642 // t.LexiconTypeID (string) (string)
5643 case "$type":
5644
5645 {
5646 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5647 if err != nil {
5648 return err
5649 }
5650
5651 t.LexiconTypeID = string(sval)
5652 }
5653 // t.Owner (string) (string)
5654 case "owner":
5655
5656 {
5657 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5658 if err != nil {
5659 return err
5660 }
5661
5662 t.Owner = string(sval)
5663 }
5664 // t.Source (string) (string)
5665 case "source":
5666
5667 {
5668 b, err := cr.ReadByte()
5669 if err != nil {
5670 return err
5671 }
5672 if b != cbg.CborNull[0] {
5673 if err := cr.UnreadByte(); err != nil {
5674 return err
5675 }
5676
5677 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5678 if err != nil {
5679 return err
5680 }
5681
5682 t.Source = (*string)(&sval)
5683 }
5684 }
5685 // t.Spindle (string) (string)
5686 case "spindle":
5687
5688 {
5689 b, err := cr.ReadByte()
5690 if err != nil {
5691 return err
5692 }
5693 if b != cbg.CborNull[0] {
5694 if err := cr.UnreadByte(); err != nil {
5695 return err
5696 }
5697
5698 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5699 if err != nil {
5700 return err
5701 }
5702
5703 t.Spindle = (*string)(&sval)
5704 }
5705 }
5706 // t.CreatedAt (string) (string)
5707 case "createdAt":
5708
5709 {
5710 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5711 if err != nil {
5712 return err
5713 }
5714
5715 t.CreatedAt = string(sval)
5716 }
5717 // t.Description (string) (string)
5718 case "description":
5719
5720 {
5721 b, err := cr.ReadByte()
5722 if err != nil {
5723 return err
5724 }
5725 if b != cbg.CborNull[0] {
5726 if err := cr.UnreadByte(); err != nil {
5727 return err
5728 }
5729
5730 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5731 if err != nil {
5732 return err
5733 }
5734
5735 t.Description = (*string)(&sval)
5736 }
5737 }
5738
5739 default:
5740 // Field doesn't exist on this type, so ignore it
5741 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5742 return err
5743 }
5744 }
5745 }
5746
5747 return nil
5748}
5749func (t *RepoArtifact) MarshalCBOR(w io.Writer) error {
5750 if t == nil {
5751 _, err := w.Write(cbg.CborNull)
5752 return err
5753 }
5754
5755 cw := cbg.NewCborWriter(w)
5756 fieldCount := 6
5757
5758 if t.Tag == nil {
5759 fieldCount--
5760 }
5761
5762 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5763 return err
5764 }
5765
5766 // t.Tag (util.LexBytes) (slice)
5767 if t.Tag != nil {
5768
5769 if len("tag") > 1000000 {
5770 return xerrors.Errorf("Value in field \"tag\" was too long")
5771 }
5772
5773 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tag"))); err != nil {
5774 return err
5775 }
5776 if _, err := cw.WriteString(string("tag")); err != nil {
5777 return err
5778 }
5779
5780 if len(t.Tag) > 2097152 {
5781 return xerrors.Errorf("Byte array in field t.Tag was too long")
5782 }
5783
5784 if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Tag))); err != nil {
5785 return err
5786 }
5787
5788 if _, err := cw.Write(t.Tag); err != nil {
5789 return err
5790 }
5791
5792 }
5793
5794 // t.Name (string) (string)
5795 if len("name") > 1000000 {
5796 return xerrors.Errorf("Value in field \"name\" was too long")
5797 }
5798
5799 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5800 return err
5801 }
5802 if _, err := cw.WriteString(string("name")); err != nil {
5803 return err
5804 }
5805
5806 if len(t.Name) > 1000000 {
5807 return xerrors.Errorf("Value in field t.Name was too long")
5808 }
5809
5810 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5811 return err
5812 }
5813 if _, err := cw.WriteString(string(t.Name)); err != nil {
5814 return err
5815 }
5816
5817 // t.Repo (string) (string)
5818 if len("repo") > 1000000 {
5819 return xerrors.Errorf("Value in field \"repo\" was too long")
5820 }
5821
5822 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5823 return err
5824 }
5825 if _, err := cw.WriteString(string("repo")); err != nil {
5826 return err
5827 }
5828
5829 if len(t.Repo) > 1000000 {
5830 return xerrors.Errorf("Value in field t.Repo was too long")
5831 }
5832
5833 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
5834 return err
5835 }
5836 if _, err := cw.WriteString(string(t.Repo)); err != nil {
5837 return err
5838 }
5839
5840 // t.LexiconTypeID (string) (string)
5841 if len("$type") > 1000000 {
5842 return xerrors.Errorf("Value in field \"$type\" was too long")
5843 }
5844
5845 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5846 return err
5847 }
5848 if _, err := cw.WriteString(string("$type")); err != nil {
5849 return err
5850 }
5851
5852 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.artifact"))); err != nil {
5853 return err
5854 }
5855 if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil {
5856 return err
5857 }
5858
5859 // t.Artifact (util.LexBlob) (struct)
5860 if len("artifact") > 1000000 {
5861 return xerrors.Errorf("Value in field \"artifact\" was too long")
5862 }
5863
5864 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("artifact"))); err != nil {
5865 return err
5866 }
5867 if _, err := cw.WriteString(string("artifact")); err != nil {
5868 return err
5869 }
5870
5871 if err := t.Artifact.MarshalCBOR(cw); err != nil {
5872 return err
5873 }
5874
5875 // t.CreatedAt (string) (string)
5876 if len("createdAt") > 1000000 {
5877 return xerrors.Errorf("Value in field \"createdAt\" was too long")
5878 }
5879
5880 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5881 return err
5882 }
5883 if _, err := cw.WriteString(string("createdAt")); err != nil {
5884 return err
5885 }
5886
5887 if len(t.CreatedAt) > 1000000 {
5888 return xerrors.Errorf("Value in field t.CreatedAt was too long")
5889 }
5890
5891 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5892 return err
5893 }
5894 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5895 return err
5896 }
5897 return nil
5898}
5899
5900func (t *RepoArtifact) UnmarshalCBOR(r io.Reader) (err error) {
5901 *t = RepoArtifact{}
5902
5903 cr := cbg.NewCborReader(r)
5904
5905 maj, extra, err := cr.ReadHeader()
5906 if err != nil {
5907 return err
5908 }
5909 defer func() {
5910 if err == io.EOF {
5911 err = io.ErrUnexpectedEOF
5912 }
5913 }()
5914
5915 if maj != cbg.MajMap {
5916 return fmt.Errorf("cbor input should be of type map")
5917 }
5918
5919 if extra > cbg.MaxLength {
5920 return fmt.Errorf("RepoArtifact: map struct too large (%d)", extra)
5921 }
5922
5923 n := extra
5924
5925 nameBuf := make([]byte, 9)
5926 for i := uint64(0); i < n; i++ {
5927 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5928 if err != nil {
5929 return err
5930 }
5931
5932 if !ok {
5933 // Field doesn't exist on this type, so ignore it
5934 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5935 return err
5936 }
5937 continue
5938 }
5939
5940 switch string(nameBuf[:nameLen]) {
5941 // t.Tag (util.LexBytes) (slice)
5942 case "tag":
5943
5944 maj, extra, err = cr.ReadHeader()
5945 if err != nil {
5946 return err
5947 }
5948
5949 if extra > 2097152 {
5950 return fmt.Errorf("t.Tag: byte array too large (%d)", extra)
5951 }
5952 if maj != cbg.MajByteString {
5953 return fmt.Errorf("expected byte array")
5954 }
5955
5956 if extra > 0 {
5957 t.Tag = make([]uint8, extra)
5958 }
5959
5960 if _, err := io.ReadFull(cr, t.Tag); err != nil {
5961 return err
5962 }
5963
5964 // t.Name (string) (string)
5965 case "name":
5966
5967 {
5968 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5969 if err != nil {
5970 return err
5971 }
5972
5973 t.Name = string(sval)
5974 }
5975 // t.Repo (string) (string)
5976 case "repo":
5977
5978 {
5979 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5980 if err != nil {
5981 return err
5982 }
5983
5984 t.Repo = string(sval)
5985 }
5986 // t.LexiconTypeID (string) (string)
5987 case "$type":
5988
5989 {
5990 sval, err := cbg.ReadStringWithMax(cr, 1000000)
5991 if err != nil {
5992 return err
5993 }
5994
5995 t.LexiconTypeID = string(sval)
5996 }
5997 // t.Artifact (util.LexBlob) (struct)
5998 case "artifact":
5999
6000 {
6001
6002 b, err := cr.ReadByte()
6003 if err != nil {
6004 return err
6005 }
6006 if b != cbg.CborNull[0] {
6007 if err := cr.UnreadByte(); err != nil {
6008 return err
6009 }
6010 t.Artifact = new(util.LexBlob)
6011 if err := t.Artifact.UnmarshalCBOR(cr); err != nil {
6012 return xerrors.Errorf("unmarshaling t.Artifact pointer: %w", err)
6013 }
6014 }
6015
6016 }
6017 // t.CreatedAt (string) (string)
6018 case "createdAt":
6019
6020 {
6021 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6022 if err != nil {
6023 return err
6024 }
6025
6026 t.CreatedAt = string(sval)
6027 }
6028
6029 default:
6030 // Field doesn't exist on this type, so ignore it
6031 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6032 return err
6033 }
6034 }
6035 }
6036
6037 return nil
6038}
6039func (t *RepoCollaborator) MarshalCBOR(w io.Writer) error {
6040 if t == nil {
6041 _, err := w.Write(cbg.CborNull)
6042 return err
6043 }
6044
6045 cw := cbg.NewCborWriter(w)
6046
6047 if _, err := cw.Write([]byte{164}); err != nil {
6048 return err
6049 }
6050
6051 // t.Repo (string) (string)
6052 if len("repo") > 1000000 {
6053 return xerrors.Errorf("Value in field \"repo\" was too long")
6054 }
6055
6056 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6057 return err
6058 }
6059 if _, err := cw.WriteString(string("repo")); err != nil {
6060 return err
6061 }
6062
6063 if len(t.Repo) > 1000000 {
6064 return xerrors.Errorf("Value in field t.Repo was too long")
6065 }
6066
6067 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
6068 return err
6069 }
6070 if _, err := cw.WriteString(string(t.Repo)); err != nil {
6071 return err
6072 }
6073
6074 // t.LexiconTypeID (string) (string)
6075 if len("$type") > 1000000 {
6076 return xerrors.Errorf("Value in field \"$type\" was too long")
6077 }
6078
6079 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6080 return err
6081 }
6082 if _, err := cw.WriteString(string("$type")); err != nil {
6083 return err
6084 }
6085
6086 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.collaborator"))); err != nil {
6087 return err
6088 }
6089 if _, err := cw.WriteString(string("sh.tangled.repo.collaborator")); err != nil {
6090 return err
6091 }
6092
6093 // t.Subject (string) (string)
6094 if len("subject") > 1000000 {
6095 return xerrors.Errorf("Value in field \"subject\" was too long")
6096 }
6097
6098 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
6099 return err
6100 }
6101 if _, err := cw.WriteString(string("subject")); err != nil {
6102 return err
6103 }
6104
6105 if len(t.Subject) > 1000000 {
6106 return xerrors.Errorf("Value in field t.Subject was too long")
6107 }
6108
6109 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
6110 return err
6111 }
6112 if _, err := cw.WriteString(string(t.Subject)); err != nil {
6113 return err
6114 }
6115
6116 // t.CreatedAt (string) (string)
6117 if len("createdAt") > 1000000 {
6118 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6119 }
6120
6121 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6122 return err
6123 }
6124 if _, err := cw.WriteString(string("createdAt")); err != nil {
6125 return err
6126 }
6127
6128 if len(t.CreatedAt) > 1000000 {
6129 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6130 }
6131
6132 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6133 return err
6134 }
6135 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6136 return err
6137 }
6138 return nil
6139}
6140
6141func (t *RepoCollaborator) UnmarshalCBOR(r io.Reader) (err error) {
6142 *t = RepoCollaborator{}
6143
6144 cr := cbg.NewCborReader(r)
6145
6146 maj, extra, err := cr.ReadHeader()
6147 if err != nil {
6148 return err
6149 }
6150 defer func() {
6151 if err == io.EOF {
6152 err = io.ErrUnexpectedEOF
6153 }
6154 }()
6155
6156 if maj != cbg.MajMap {
6157 return fmt.Errorf("cbor input should be of type map")
6158 }
6159
6160 if extra > cbg.MaxLength {
6161 return fmt.Errorf("RepoCollaborator: map struct too large (%d)", extra)
6162 }
6163
6164 n := extra
6165
6166 nameBuf := make([]byte, 9)
6167 for i := uint64(0); i < n; i++ {
6168 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6169 if err != nil {
6170 return err
6171 }
6172
6173 if !ok {
6174 // Field doesn't exist on this type, so ignore it
6175 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6176 return err
6177 }
6178 continue
6179 }
6180
6181 switch string(nameBuf[:nameLen]) {
6182 // t.Repo (string) (string)
6183 case "repo":
6184
6185 {
6186 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6187 if err != nil {
6188 return err
6189 }
6190
6191 t.Repo = string(sval)
6192 }
6193 // t.LexiconTypeID (string) (string)
6194 case "$type":
6195
6196 {
6197 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6198 if err != nil {
6199 return err
6200 }
6201
6202 t.LexiconTypeID = string(sval)
6203 }
6204 // t.Subject (string) (string)
6205 case "subject":
6206
6207 {
6208 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6209 if err != nil {
6210 return err
6211 }
6212
6213 t.Subject = string(sval)
6214 }
6215 // t.CreatedAt (string) (string)
6216 case "createdAt":
6217
6218 {
6219 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6220 if err != nil {
6221 return err
6222 }
6223
6224 t.CreatedAt = string(sval)
6225 }
6226
6227 default:
6228 // Field doesn't exist on this type, so ignore it
6229 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6230 return err
6231 }
6232 }
6233 }
6234
6235 return nil
6236}
6237func (t *RepoIssue) MarshalCBOR(w io.Writer) error {
6238 if t == nil {
6239 _, err := w.Write(cbg.CborNull)
6240 return err
6241 }
6242
6243 cw := cbg.NewCborWriter(w)
6244 fieldCount := 5
6245
6246 if t.Body == nil {
6247 fieldCount--
6248 }
6249
6250 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6251 return err
6252 }
6253
6254 // t.Body (string) (string)
6255 if t.Body != nil {
6256
6257 if len("body") > 1000000 {
6258 return xerrors.Errorf("Value in field \"body\" was too long")
6259 }
6260
6261 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
6262 return err
6263 }
6264 if _, err := cw.WriteString(string("body")); err != nil {
6265 return err
6266 }
6267
6268 if t.Body == nil {
6269 if _, err := cw.Write(cbg.CborNull); err != nil {
6270 return err
6271 }
6272 } else {
6273 if len(*t.Body) > 1000000 {
6274 return xerrors.Errorf("Value in field t.Body was too long")
6275 }
6276
6277 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
6278 return err
6279 }
6280 if _, err := cw.WriteString(string(*t.Body)); err != nil {
6281 return err
6282 }
6283 }
6284 }
6285
6286 // t.Repo (string) (string)
6287 if len("repo") > 1000000 {
6288 return xerrors.Errorf("Value in field \"repo\" was too long")
6289 }
6290
6291 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6292 return err
6293 }
6294 if _, err := cw.WriteString(string("repo")); err != nil {
6295 return err
6296 }
6297
6298 if len(t.Repo) > 1000000 {
6299 return xerrors.Errorf("Value in field t.Repo was too long")
6300 }
6301
6302 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
6303 return err
6304 }
6305 if _, err := cw.WriteString(string(t.Repo)); err != nil {
6306 return err
6307 }
6308
6309 // t.LexiconTypeID (string) (string)
6310 if len("$type") > 1000000 {
6311 return xerrors.Errorf("Value in field \"$type\" was too long")
6312 }
6313
6314 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6315 return err
6316 }
6317 if _, err := cw.WriteString(string("$type")); err != nil {
6318 return err
6319 }
6320
6321 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil {
6322 return err
6323 }
6324 if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil {
6325 return err
6326 }
6327
6328 // t.Title (string) (string)
6329 if len("title") > 1000000 {
6330 return xerrors.Errorf("Value in field \"title\" was too long")
6331 }
6332
6333 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
6334 return err
6335 }
6336 if _, err := cw.WriteString(string("title")); err != nil {
6337 return err
6338 }
6339
6340 if len(t.Title) > 1000000 {
6341 return xerrors.Errorf("Value in field t.Title was too long")
6342 }
6343
6344 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
6345 return err
6346 }
6347 if _, err := cw.WriteString(string(t.Title)); err != nil {
6348 return err
6349 }
6350
6351 // t.CreatedAt (string) (string)
6352 if len("createdAt") > 1000000 {
6353 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6354 }
6355
6356 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6357 return err
6358 }
6359 if _, err := cw.WriteString(string("createdAt")); err != nil {
6360 return err
6361 }
6362
6363 if len(t.CreatedAt) > 1000000 {
6364 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6365 }
6366
6367 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6368 return err
6369 }
6370 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6371 return err
6372 }
6373 return nil
6374}
6375
6376func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) {
6377 *t = RepoIssue{}
6378
6379 cr := cbg.NewCborReader(r)
6380
6381 maj, extra, err := cr.ReadHeader()
6382 if err != nil {
6383 return err
6384 }
6385 defer func() {
6386 if err == io.EOF {
6387 err = io.ErrUnexpectedEOF
6388 }
6389 }()
6390
6391 if maj != cbg.MajMap {
6392 return fmt.Errorf("cbor input should be of type map")
6393 }
6394
6395 if extra > cbg.MaxLength {
6396 return fmt.Errorf("RepoIssue: map struct too large (%d)", extra)
6397 }
6398
6399 n := extra
6400
6401 nameBuf := make([]byte, 9)
6402 for i := uint64(0); i < n; i++ {
6403 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6404 if err != nil {
6405 return err
6406 }
6407
6408 if !ok {
6409 // Field doesn't exist on this type, so ignore it
6410 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6411 return err
6412 }
6413 continue
6414 }
6415
6416 switch string(nameBuf[:nameLen]) {
6417 // t.Body (string) (string)
6418 case "body":
6419
6420 {
6421 b, err := cr.ReadByte()
6422 if err != nil {
6423 return err
6424 }
6425 if b != cbg.CborNull[0] {
6426 if err := cr.UnreadByte(); err != nil {
6427 return err
6428 }
6429
6430 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6431 if err != nil {
6432 return err
6433 }
6434
6435 t.Body = (*string)(&sval)
6436 }
6437 }
6438 // t.Repo (string) (string)
6439 case "repo":
6440
6441 {
6442 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6443 if err != nil {
6444 return err
6445 }
6446
6447 t.Repo = string(sval)
6448 }
6449 // t.LexiconTypeID (string) (string)
6450 case "$type":
6451
6452 {
6453 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6454 if err != nil {
6455 return err
6456 }
6457
6458 t.LexiconTypeID = string(sval)
6459 }
6460 // t.Title (string) (string)
6461 case "title":
6462
6463 {
6464 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6465 if err != nil {
6466 return err
6467 }
6468
6469 t.Title = string(sval)
6470 }
6471 // t.CreatedAt (string) (string)
6472 case "createdAt":
6473
6474 {
6475 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6476 if err != nil {
6477 return err
6478 }
6479
6480 t.CreatedAt = string(sval)
6481 }
6482
6483 default:
6484 // Field doesn't exist on this type, so ignore it
6485 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6486 return err
6487 }
6488 }
6489 }
6490
6491 return nil
6492}
6493func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error {
6494 if t == nil {
6495 _, err := w.Write(cbg.CborNull)
6496 return err
6497 }
6498
6499 cw := cbg.NewCborWriter(w)
6500 fieldCount := 5
6501
6502 if t.ReplyTo == nil {
6503 fieldCount--
6504 }
6505
6506 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6507 return err
6508 }
6509
6510 // t.Body (string) (string)
6511 if len("body") > 1000000 {
6512 return xerrors.Errorf("Value in field \"body\" was too long")
6513 }
6514
6515 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
6516 return err
6517 }
6518 if _, err := cw.WriteString(string("body")); err != nil {
6519 return err
6520 }
6521
6522 if len(t.Body) > 1000000 {
6523 return xerrors.Errorf("Value in field t.Body was too long")
6524 }
6525
6526 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
6527 return err
6528 }
6529 if _, err := cw.WriteString(string(t.Body)); err != nil {
6530 return err
6531 }
6532
6533 // t.LexiconTypeID (string) (string)
6534 if len("$type") > 1000000 {
6535 return xerrors.Errorf("Value in field \"$type\" was too long")
6536 }
6537
6538 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6539 return err
6540 }
6541 if _, err := cw.WriteString(string("$type")); err != nil {
6542 return err
6543 }
6544
6545 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil {
6546 return err
6547 }
6548 if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil {
6549 return err
6550 }
6551
6552 // t.Issue (string) (string)
6553 if len("issue") > 1000000 {
6554 return xerrors.Errorf("Value in field \"issue\" was too long")
6555 }
6556
6557 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
6558 return err
6559 }
6560 if _, err := cw.WriteString(string("issue")); err != nil {
6561 return err
6562 }
6563
6564 if len(t.Issue) > 1000000 {
6565 return xerrors.Errorf("Value in field t.Issue was too long")
6566 }
6567
6568 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
6569 return err
6570 }
6571 if _, err := cw.WriteString(string(t.Issue)); err != nil {
6572 return err
6573 }
6574
6575 // t.ReplyTo (string) (string)
6576 if t.ReplyTo != nil {
6577
6578 if len("replyTo") > 1000000 {
6579 return xerrors.Errorf("Value in field \"replyTo\" was too long")
6580 }
6581
6582 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("replyTo"))); err != nil {
6583 return err
6584 }
6585 if _, err := cw.WriteString(string("replyTo")); err != nil {
6586 return err
6587 }
6588
6589 if t.ReplyTo == nil {
6590 if _, err := cw.Write(cbg.CborNull); err != nil {
6591 return err
6592 }
6593 } else {
6594 if len(*t.ReplyTo) > 1000000 {
6595 return xerrors.Errorf("Value in field t.ReplyTo was too long")
6596 }
6597
6598 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ReplyTo))); err != nil {
6599 return err
6600 }
6601 if _, err := cw.WriteString(string(*t.ReplyTo)); err != nil {
6602 return err
6603 }
6604 }
6605 }
6606
6607 // t.CreatedAt (string) (string)
6608 if len("createdAt") > 1000000 {
6609 return xerrors.Errorf("Value in field \"createdAt\" was too long")
6610 }
6611
6612 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6613 return err
6614 }
6615 if _, err := cw.WriteString(string("createdAt")); err != nil {
6616 return err
6617 }
6618
6619 if len(t.CreatedAt) > 1000000 {
6620 return xerrors.Errorf("Value in field t.CreatedAt was too long")
6621 }
6622
6623 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6624 return err
6625 }
6626 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6627 return err
6628 }
6629 return nil
6630}
6631
6632func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) {
6633 *t = RepoIssueComment{}
6634
6635 cr := cbg.NewCborReader(r)
6636
6637 maj, extra, err := cr.ReadHeader()
6638 if err != nil {
6639 return err
6640 }
6641 defer func() {
6642 if err == io.EOF {
6643 err = io.ErrUnexpectedEOF
6644 }
6645 }()
6646
6647 if maj != cbg.MajMap {
6648 return fmt.Errorf("cbor input should be of type map")
6649 }
6650
6651 if extra > cbg.MaxLength {
6652 return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra)
6653 }
6654
6655 n := extra
6656
6657 nameBuf := make([]byte, 9)
6658 for i := uint64(0); i < n; i++ {
6659 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6660 if err != nil {
6661 return err
6662 }
6663
6664 if !ok {
6665 // Field doesn't exist on this type, so ignore it
6666 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6667 return err
6668 }
6669 continue
6670 }
6671
6672 switch string(nameBuf[:nameLen]) {
6673 // t.Body (string) (string)
6674 case "body":
6675
6676 {
6677 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6678 if err != nil {
6679 return err
6680 }
6681
6682 t.Body = string(sval)
6683 }
6684 // t.LexiconTypeID (string) (string)
6685 case "$type":
6686
6687 {
6688 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6689 if err != nil {
6690 return err
6691 }
6692
6693 t.LexiconTypeID = string(sval)
6694 }
6695 // t.Issue (string) (string)
6696 case "issue":
6697
6698 {
6699 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6700 if err != nil {
6701 return err
6702 }
6703
6704 t.Issue = string(sval)
6705 }
6706 // t.ReplyTo (string) (string)
6707 case "replyTo":
6708
6709 {
6710 b, err := cr.ReadByte()
6711 if err != nil {
6712 return err
6713 }
6714 if b != cbg.CborNull[0] {
6715 if err := cr.UnreadByte(); err != nil {
6716 return err
6717 }
6718
6719 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6720 if err != nil {
6721 return err
6722 }
6723
6724 t.ReplyTo = (*string)(&sval)
6725 }
6726 }
6727 // t.CreatedAt (string) (string)
6728 case "createdAt":
6729
6730 {
6731 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6732 if err != nil {
6733 return err
6734 }
6735
6736 t.CreatedAt = string(sval)
6737 }
6738
6739 default:
6740 // Field doesn't exist on this type, so ignore it
6741 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6742 return err
6743 }
6744 }
6745 }
6746
6747 return nil
6748}
6749func (t *RepoIssueState) MarshalCBOR(w io.Writer) error {
6750 if t == nil {
6751 _, err := w.Write(cbg.CborNull)
6752 return err
6753 }
6754
6755 cw := cbg.NewCborWriter(w)
6756
6757 if _, err := cw.Write([]byte{163}); err != nil {
6758 return err
6759 }
6760
6761 // t.LexiconTypeID (string) (string)
6762 if len("$type") > 1000000 {
6763 return xerrors.Errorf("Value in field \"$type\" was too long")
6764 }
6765
6766 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6767 return err
6768 }
6769 if _, err := cw.WriteString(string("$type")); err != nil {
6770 return err
6771 }
6772
6773 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil {
6774 return err
6775 }
6776 if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil {
6777 return err
6778 }
6779
6780 // t.Issue (string) (string)
6781 if len("issue") > 1000000 {
6782 return xerrors.Errorf("Value in field \"issue\" was too long")
6783 }
6784
6785 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
6786 return err
6787 }
6788 if _, err := cw.WriteString(string("issue")); err != nil {
6789 return err
6790 }
6791
6792 if len(t.Issue) > 1000000 {
6793 return xerrors.Errorf("Value in field t.Issue was too long")
6794 }
6795
6796 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
6797 return err
6798 }
6799 if _, err := cw.WriteString(string(t.Issue)); err != nil {
6800 return err
6801 }
6802
6803 // t.State (string) (string)
6804 if len("state") > 1000000 {
6805 return xerrors.Errorf("Value in field \"state\" was too long")
6806 }
6807
6808 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil {
6809 return err
6810 }
6811 if _, err := cw.WriteString(string("state")); err != nil {
6812 return err
6813 }
6814
6815 if len(t.State) > 1000000 {
6816 return xerrors.Errorf("Value in field t.State was too long")
6817 }
6818
6819 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil {
6820 return err
6821 }
6822 if _, err := cw.WriteString(string(t.State)); err != nil {
6823 return err
6824 }
6825 return nil
6826}
6827
6828func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) {
6829 *t = RepoIssueState{}
6830
6831 cr := cbg.NewCborReader(r)
6832
6833 maj, extra, err := cr.ReadHeader()
6834 if err != nil {
6835 return err
6836 }
6837 defer func() {
6838 if err == io.EOF {
6839 err = io.ErrUnexpectedEOF
6840 }
6841 }()
6842
6843 if maj != cbg.MajMap {
6844 return fmt.Errorf("cbor input should be of type map")
6845 }
6846
6847 if extra > cbg.MaxLength {
6848 return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra)
6849 }
6850
6851 n := extra
6852
6853 nameBuf := make([]byte, 5)
6854 for i := uint64(0); i < n; i++ {
6855 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6856 if err != nil {
6857 return err
6858 }
6859
6860 if !ok {
6861 // Field doesn't exist on this type, so ignore it
6862 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6863 return err
6864 }
6865 continue
6866 }
6867
6868 switch string(nameBuf[:nameLen]) {
6869 // t.LexiconTypeID (string) (string)
6870 case "$type":
6871
6872 {
6873 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6874 if err != nil {
6875 return err
6876 }
6877
6878 t.LexiconTypeID = string(sval)
6879 }
6880 // t.Issue (string) (string)
6881 case "issue":
6882
6883 {
6884 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6885 if err != nil {
6886 return err
6887 }
6888
6889 t.Issue = string(sval)
6890 }
6891 // t.State (string) (string)
6892 case "state":
6893
6894 {
6895 sval, err := cbg.ReadStringWithMax(cr, 1000000)
6896 if err != nil {
6897 return err
6898 }
6899
6900 t.State = string(sval)
6901 }
6902
6903 default:
6904 // Field doesn't exist on this type, so ignore it
6905 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6906 return err
6907 }
6908 }
6909 }
6910
6911 return nil
6912}
6913func (t *RepoPull) MarshalCBOR(w io.Writer) error {
6914 if t == nil {
6915 _, err := w.Write(cbg.CborNull)
6916 return err
6917 }
6918
6919 cw := cbg.NewCborWriter(w)
6920 fieldCount := 7
6921
6922 if t.Body == nil {
6923 fieldCount--
6924 }
6925
6926 if t.Source == nil {
6927 fieldCount--
6928 }
6929
6930 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6931 return err
6932 }
6933
6934 // t.Body (string) (string)
6935 if t.Body != nil {
6936
6937 if len("body") > 1000000 {
6938 return xerrors.Errorf("Value in field \"body\" was too long")
6939 }
6940
6941 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
6942 return err
6943 }
6944 if _, err := cw.WriteString(string("body")); err != nil {
6945 return err
6946 }
6947
6948 if t.Body == nil {
6949 if _, err := cw.Write(cbg.CborNull); err != nil {
6950 return err
6951 }
6952 } else {
6953 if len(*t.Body) > 1000000 {
6954 return xerrors.Errorf("Value in field t.Body was too long")
6955 }
6956
6957 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
6958 return err
6959 }
6960 if _, err := cw.WriteString(string(*t.Body)); err != nil {
6961 return err
6962 }
6963 }
6964 }
6965
6966 // t.LexiconTypeID (string) (string)
6967 if len("$type") > 1000000 {
6968 return xerrors.Errorf("Value in field \"$type\" was too long")
6969 }
6970
6971 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6972 return err
6973 }
6974 if _, err := cw.WriteString(string("$type")); err != nil {
6975 return err
6976 }
6977
6978 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil {
6979 return err
6980 }
6981 if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil {
6982 return err
6983 }
6984
6985 // t.Patch (string) (string)
6986 if len("patch") > 1000000 {
6987 return xerrors.Errorf("Value in field \"patch\" was too long")
6988 }
6989
6990 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil {
6991 return err
6992 }
6993 if _, err := cw.WriteString(string("patch")); err != nil {
6994 return err
6995 }
6996
6997 if len(t.Patch) > 1000000 {
6998 return xerrors.Errorf("Value in field t.Patch was too long")
6999 }
7000
7001 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Patch))); err != nil {
7002 return err
7003 }
7004 if _, err := cw.WriteString(string(t.Patch)); err != nil {
7005 return err
7006 }
7007
7008 // t.Title (string) (string)
7009 if len("title") > 1000000 {
7010 return xerrors.Errorf("Value in field \"title\" was too long")
7011 }
7012
7013 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
7014 return err
7015 }
7016 if _, err := cw.WriteString(string("title")); err != nil {
7017 return err
7018 }
7019
7020 if len(t.Title) > 1000000 {
7021 return xerrors.Errorf("Value in field t.Title was too long")
7022 }
7023
7024 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
7025 return err
7026 }
7027 if _, err := cw.WriteString(string(t.Title)); err != nil {
7028 return err
7029 }
7030
7031 // t.Source (tangled.RepoPull_Source) (struct)
7032 if t.Source != nil {
7033
7034 if len("source") > 1000000 {
7035 return xerrors.Errorf("Value in field \"source\" was too long")
7036 }
7037
7038 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
7039 return err
7040 }
7041 if _, err := cw.WriteString(string("source")); err != nil {
7042 return err
7043 }
7044
7045 if err := t.Source.MarshalCBOR(cw); err != nil {
7046 return err
7047 }
7048 }
7049
7050 // t.Target (tangled.RepoPull_Target) (struct)
7051 if len("target") > 1000000 {
7052 return xerrors.Errorf("Value in field \"target\" was too long")
7053 }
7054
7055 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("target"))); err != nil {
7056 return err
7057 }
7058 if _, err := cw.WriteString(string("target")); err != nil {
7059 return err
7060 }
7061
7062 if err := t.Target.MarshalCBOR(cw); err != nil {
7063 return err
7064 }
7065
7066 // t.CreatedAt (string) (string)
7067 if len("createdAt") > 1000000 {
7068 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7069 }
7070
7071 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7072 return err
7073 }
7074 if _, err := cw.WriteString(string("createdAt")); err != nil {
7075 return err
7076 }
7077
7078 if len(t.CreatedAt) > 1000000 {
7079 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7080 }
7081
7082 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7083 return err
7084 }
7085 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7086 return err
7087 }
7088 return nil
7089}
7090
7091func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) {
7092 *t = RepoPull{}
7093
7094 cr := cbg.NewCborReader(r)
7095
7096 maj, extra, err := cr.ReadHeader()
7097 if err != nil {
7098 return err
7099 }
7100 defer func() {
7101 if err == io.EOF {
7102 err = io.ErrUnexpectedEOF
7103 }
7104 }()
7105
7106 if maj != cbg.MajMap {
7107 return fmt.Errorf("cbor input should be of type map")
7108 }
7109
7110 if extra > cbg.MaxLength {
7111 return fmt.Errorf("RepoPull: map struct too large (%d)", extra)
7112 }
7113
7114 n := extra
7115
7116 nameBuf := make([]byte, 9)
7117 for i := uint64(0); i < n; i++ {
7118 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7119 if err != nil {
7120 return err
7121 }
7122
7123 if !ok {
7124 // Field doesn't exist on this type, so ignore it
7125 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7126 return err
7127 }
7128 continue
7129 }
7130
7131 switch string(nameBuf[:nameLen]) {
7132 // t.Body (string) (string)
7133 case "body":
7134
7135 {
7136 b, err := cr.ReadByte()
7137 if err != nil {
7138 return err
7139 }
7140 if b != cbg.CborNull[0] {
7141 if err := cr.UnreadByte(); err != nil {
7142 return err
7143 }
7144
7145 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7146 if err != nil {
7147 return err
7148 }
7149
7150 t.Body = (*string)(&sval)
7151 }
7152 }
7153 // t.LexiconTypeID (string) (string)
7154 case "$type":
7155
7156 {
7157 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7158 if err != nil {
7159 return err
7160 }
7161
7162 t.LexiconTypeID = string(sval)
7163 }
7164 // t.Patch (string) (string)
7165 case "patch":
7166
7167 {
7168 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7169 if err != nil {
7170 return err
7171 }
7172
7173 t.Patch = string(sval)
7174 }
7175 // t.Title (string) (string)
7176 case "title":
7177
7178 {
7179 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7180 if err != nil {
7181 return err
7182 }
7183
7184 t.Title = string(sval)
7185 }
7186 // t.Source (tangled.RepoPull_Source) (struct)
7187 case "source":
7188
7189 {
7190
7191 b, err := cr.ReadByte()
7192 if err != nil {
7193 return err
7194 }
7195 if b != cbg.CborNull[0] {
7196 if err := cr.UnreadByte(); err != nil {
7197 return err
7198 }
7199 t.Source = new(RepoPull_Source)
7200 if err := t.Source.UnmarshalCBOR(cr); err != nil {
7201 return xerrors.Errorf("unmarshaling t.Source pointer: %w", err)
7202 }
7203 }
7204
7205 }
7206 // t.Target (tangled.RepoPull_Target) (struct)
7207 case "target":
7208
7209 {
7210
7211 b, err := cr.ReadByte()
7212 if err != nil {
7213 return err
7214 }
7215 if b != cbg.CborNull[0] {
7216 if err := cr.UnreadByte(); err != nil {
7217 return err
7218 }
7219 t.Target = new(RepoPull_Target)
7220 if err := t.Target.UnmarshalCBOR(cr); err != nil {
7221 return xerrors.Errorf("unmarshaling t.Target pointer: %w", err)
7222 }
7223 }
7224
7225 }
7226 // t.CreatedAt (string) (string)
7227 case "createdAt":
7228
7229 {
7230 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7231 if err != nil {
7232 return err
7233 }
7234
7235 t.CreatedAt = string(sval)
7236 }
7237
7238 default:
7239 // Field doesn't exist on this type, so ignore it
7240 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7241 return err
7242 }
7243 }
7244 }
7245
7246 return nil
7247}
7248func (t *RepoPullComment) MarshalCBOR(w io.Writer) error {
7249 if t == nil {
7250 _, err := w.Write(cbg.CborNull)
7251 return err
7252 }
7253
7254 cw := cbg.NewCborWriter(w)
7255
7256 if _, err := cw.Write([]byte{164}); err != nil {
7257 return err
7258 }
7259
7260 // t.Body (string) (string)
7261 if len("body") > 1000000 {
7262 return xerrors.Errorf("Value in field \"body\" was too long")
7263 }
7264
7265 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
7266 return err
7267 }
7268 if _, err := cw.WriteString(string("body")); err != nil {
7269 return err
7270 }
7271
7272 if len(t.Body) > 1000000 {
7273 return xerrors.Errorf("Value in field t.Body was too long")
7274 }
7275
7276 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
7277 return err
7278 }
7279 if _, err := cw.WriteString(string(t.Body)); err != nil {
7280 return err
7281 }
7282
7283 // t.Pull (string) (string)
7284 if len("pull") > 1000000 {
7285 return xerrors.Errorf("Value in field \"pull\" was too long")
7286 }
7287
7288 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
7289 return err
7290 }
7291 if _, err := cw.WriteString(string("pull")); err != nil {
7292 return err
7293 }
7294
7295 if len(t.Pull) > 1000000 {
7296 return xerrors.Errorf("Value in field t.Pull was too long")
7297 }
7298
7299 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
7300 return err
7301 }
7302 if _, err := cw.WriteString(string(t.Pull)); err != nil {
7303 return err
7304 }
7305
7306 // t.LexiconTypeID (string) (string)
7307 if len("$type") > 1000000 {
7308 return xerrors.Errorf("Value in field \"$type\" was too long")
7309 }
7310
7311 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7312 return err
7313 }
7314 if _, err := cw.WriteString(string("$type")); err != nil {
7315 return err
7316 }
7317
7318 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.comment"))); err != nil {
7319 return err
7320 }
7321 if _, err := cw.WriteString(string("sh.tangled.repo.pull.comment")); err != nil {
7322 return err
7323 }
7324
7325 // t.CreatedAt (string) (string)
7326 if len("createdAt") > 1000000 {
7327 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7328 }
7329
7330 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7331 return err
7332 }
7333 if _, err := cw.WriteString(string("createdAt")); err != nil {
7334 return err
7335 }
7336
7337 if len(t.CreatedAt) > 1000000 {
7338 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7339 }
7340
7341 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7342 return err
7343 }
7344 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7345 return err
7346 }
7347 return nil
7348}
7349
7350func (t *RepoPullComment) UnmarshalCBOR(r io.Reader) (err error) {
7351 *t = RepoPullComment{}
7352
7353 cr := cbg.NewCborReader(r)
7354
7355 maj, extra, err := cr.ReadHeader()
7356 if err != nil {
7357 return err
7358 }
7359 defer func() {
7360 if err == io.EOF {
7361 err = io.ErrUnexpectedEOF
7362 }
7363 }()
7364
7365 if maj != cbg.MajMap {
7366 return fmt.Errorf("cbor input should be of type map")
7367 }
7368
7369 if extra > cbg.MaxLength {
7370 return fmt.Errorf("RepoPullComment: map struct too large (%d)", extra)
7371 }
7372
7373 n := extra
7374
7375 nameBuf := make([]byte, 9)
7376 for i := uint64(0); i < n; i++ {
7377 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7378 if err != nil {
7379 return err
7380 }
7381
7382 if !ok {
7383 // Field doesn't exist on this type, so ignore it
7384 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7385 return err
7386 }
7387 continue
7388 }
7389
7390 switch string(nameBuf[:nameLen]) {
7391 // t.Body (string) (string)
7392 case "body":
7393
7394 {
7395 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7396 if err != nil {
7397 return err
7398 }
7399
7400 t.Body = string(sval)
7401 }
7402 // t.Pull (string) (string)
7403 case "pull":
7404
7405 {
7406 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7407 if err != nil {
7408 return err
7409 }
7410
7411 t.Pull = string(sval)
7412 }
7413 // t.LexiconTypeID (string) (string)
7414 case "$type":
7415
7416 {
7417 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7418 if err != nil {
7419 return err
7420 }
7421
7422 t.LexiconTypeID = string(sval)
7423 }
7424 // t.CreatedAt (string) (string)
7425 case "createdAt":
7426
7427 {
7428 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7429 if err != nil {
7430 return err
7431 }
7432
7433 t.CreatedAt = string(sval)
7434 }
7435
7436 default:
7437 // Field doesn't exist on this type, so ignore it
7438 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7439 return err
7440 }
7441 }
7442 }
7443
7444 return nil
7445}
7446func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error {
7447 if t == nil {
7448 _, err := w.Write(cbg.CborNull)
7449 return err
7450 }
7451
7452 cw := cbg.NewCborWriter(w)
7453 fieldCount := 3
7454
7455 if t.Repo == nil {
7456 fieldCount--
7457 }
7458
7459 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7460 return err
7461 }
7462
7463 // t.Sha (string) (string)
7464 if len("sha") > 1000000 {
7465 return xerrors.Errorf("Value in field \"sha\" was too long")
7466 }
7467
7468 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sha"))); err != nil {
7469 return err
7470 }
7471 if _, err := cw.WriteString(string("sha")); err != nil {
7472 return err
7473 }
7474
7475 if len(t.Sha) > 1000000 {
7476 return xerrors.Errorf("Value in field t.Sha was too long")
7477 }
7478
7479 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Sha))); err != nil {
7480 return err
7481 }
7482 if _, err := cw.WriteString(string(t.Sha)); err != nil {
7483 return err
7484 }
7485
7486 // t.Repo (string) (string)
7487 if t.Repo != nil {
7488
7489 if len("repo") > 1000000 {
7490 return xerrors.Errorf("Value in field \"repo\" was too long")
7491 }
7492
7493 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
7494 return err
7495 }
7496 if _, err := cw.WriteString(string("repo")); err != nil {
7497 return err
7498 }
7499
7500 if t.Repo == nil {
7501 if _, err := cw.Write(cbg.CborNull); err != nil {
7502 return err
7503 }
7504 } else {
7505 if len(*t.Repo) > 1000000 {
7506 return xerrors.Errorf("Value in field t.Repo was too long")
7507 }
7508
7509 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
7510 return err
7511 }
7512 if _, err := cw.WriteString(string(*t.Repo)); err != nil {
7513 return err
7514 }
7515 }
7516 }
7517
7518 // t.Branch (string) (string)
7519 if len("branch") > 1000000 {
7520 return xerrors.Errorf("Value in field \"branch\" was too long")
7521 }
7522
7523 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
7524 return err
7525 }
7526 if _, err := cw.WriteString(string("branch")); err != nil {
7527 return err
7528 }
7529
7530 if len(t.Branch) > 1000000 {
7531 return xerrors.Errorf("Value in field t.Branch was too long")
7532 }
7533
7534 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
7535 return err
7536 }
7537 if _, err := cw.WriteString(string(t.Branch)); err != nil {
7538 return err
7539 }
7540 return nil
7541}
7542
7543func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) {
7544 *t = RepoPull_Source{}
7545
7546 cr := cbg.NewCborReader(r)
7547
7548 maj, extra, err := cr.ReadHeader()
7549 if err != nil {
7550 return err
7551 }
7552 defer func() {
7553 if err == io.EOF {
7554 err = io.ErrUnexpectedEOF
7555 }
7556 }()
7557
7558 if maj != cbg.MajMap {
7559 return fmt.Errorf("cbor input should be of type map")
7560 }
7561
7562 if extra > cbg.MaxLength {
7563 return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra)
7564 }
7565
7566 n := extra
7567
7568 nameBuf := make([]byte, 6)
7569 for i := uint64(0); i < n; i++ {
7570 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7571 if err != nil {
7572 return err
7573 }
7574
7575 if !ok {
7576 // Field doesn't exist on this type, so ignore it
7577 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7578 return err
7579 }
7580 continue
7581 }
7582
7583 switch string(nameBuf[:nameLen]) {
7584 // t.Sha (string) (string)
7585 case "sha":
7586
7587 {
7588 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7589 if err != nil {
7590 return err
7591 }
7592
7593 t.Sha = string(sval)
7594 }
7595 // t.Repo (string) (string)
7596 case "repo":
7597
7598 {
7599 b, err := cr.ReadByte()
7600 if err != nil {
7601 return err
7602 }
7603 if b != cbg.CborNull[0] {
7604 if err := cr.UnreadByte(); err != nil {
7605 return err
7606 }
7607
7608 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7609 if err != nil {
7610 return err
7611 }
7612
7613 t.Repo = (*string)(&sval)
7614 }
7615 }
7616 // t.Branch (string) (string)
7617 case "branch":
7618
7619 {
7620 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7621 if err != nil {
7622 return err
7623 }
7624
7625 t.Branch = string(sval)
7626 }
7627
7628 default:
7629 // Field doesn't exist on this type, so ignore it
7630 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7631 return err
7632 }
7633 }
7634 }
7635
7636 return nil
7637}
7638func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error {
7639 if t == nil {
7640 _, err := w.Write(cbg.CborNull)
7641 return err
7642 }
7643
7644 cw := cbg.NewCborWriter(w)
7645
7646 if _, err := cw.Write([]byte{163}); err != nil {
7647 return err
7648 }
7649
7650 // t.Pull (string) (string)
7651 if len("pull") > 1000000 {
7652 return xerrors.Errorf("Value in field \"pull\" was too long")
7653 }
7654
7655 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
7656 return err
7657 }
7658 if _, err := cw.WriteString(string("pull")); err != nil {
7659 return err
7660 }
7661
7662 if len(t.Pull) > 1000000 {
7663 return xerrors.Errorf("Value in field t.Pull was too long")
7664 }
7665
7666 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
7667 return err
7668 }
7669 if _, err := cw.WriteString(string(t.Pull)); err != nil {
7670 return err
7671 }
7672
7673 // t.LexiconTypeID (string) (string)
7674 if len("$type") > 1000000 {
7675 return xerrors.Errorf("Value in field \"$type\" was too long")
7676 }
7677
7678 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7679 return err
7680 }
7681 if _, err := cw.WriteString(string("$type")); err != nil {
7682 return err
7683 }
7684
7685 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil {
7686 return err
7687 }
7688 if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil {
7689 return err
7690 }
7691
7692 // t.Status (string) (string)
7693 if len("status") > 1000000 {
7694 return xerrors.Errorf("Value in field \"status\" was too long")
7695 }
7696
7697 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
7698 return err
7699 }
7700 if _, err := cw.WriteString(string("status")); err != nil {
7701 return err
7702 }
7703
7704 if len(t.Status) > 1000000 {
7705 return xerrors.Errorf("Value in field t.Status was too long")
7706 }
7707
7708 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
7709 return err
7710 }
7711 if _, err := cw.WriteString(string(t.Status)); err != nil {
7712 return err
7713 }
7714 return nil
7715}
7716
7717func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) {
7718 *t = RepoPullStatus{}
7719
7720 cr := cbg.NewCborReader(r)
7721
7722 maj, extra, err := cr.ReadHeader()
7723 if err != nil {
7724 return err
7725 }
7726 defer func() {
7727 if err == io.EOF {
7728 err = io.ErrUnexpectedEOF
7729 }
7730 }()
7731
7732 if maj != cbg.MajMap {
7733 return fmt.Errorf("cbor input should be of type map")
7734 }
7735
7736 if extra > cbg.MaxLength {
7737 return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra)
7738 }
7739
7740 n := extra
7741
7742 nameBuf := make([]byte, 6)
7743 for i := uint64(0); i < n; i++ {
7744 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7745 if err != nil {
7746 return err
7747 }
7748
7749 if !ok {
7750 // Field doesn't exist on this type, so ignore it
7751 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7752 return err
7753 }
7754 continue
7755 }
7756
7757 switch string(nameBuf[:nameLen]) {
7758 // t.Pull (string) (string)
7759 case "pull":
7760
7761 {
7762 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7763 if err != nil {
7764 return err
7765 }
7766
7767 t.Pull = string(sval)
7768 }
7769 // t.LexiconTypeID (string) (string)
7770 case "$type":
7771
7772 {
7773 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7774 if err != nil {
7775 return err
7776 }
7777
7778 t.LexiconTypeID = string(sval)
7779 }
7780 // t.Status (string) (string)
7781 case "status":
7782
7783 {
7784 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7785 if err != nil {
7786 return err
7787 }
7788
7789 t.Status = string(sval)
7790 }
7791
7792 default:
7793 // Field doesn't exist on this type, so ignore it
7794 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7795 return err
7796 }
7797 }
7798 }
7799
7800 return nil
7801}
7802func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error {
7803 if t == nil {
7804 _, err := w.Write(cbg.CborNull)
7805 return err
7806 }
7807
7808 cw := cbg.NewCborWriter(w)
7809
7810 if _, err := cw.Write([]byte{162}); err != nil {
7811 return err
7812 }
7813
7814 // t.Repo (string) (string)
7815 if len("repo") > 1000000 {
7816 return xerrors.Errorf("Value in field \"repo\" was too long")
7817 }
7818
7819 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
7820 return err
7821 }
7822 if _, err := cw.WriteString(string("repo")); err != nil {
7823 return err
7824 }
7825
7826 if len(t.Repo) > 1000000 {
7827 return xerrors.Errorf("Value in field t.Repo was too long")
7828 }
7829
7830 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
7831 return err
7832 }
7833 if _, err := cw.WriteString(string(t.Repo)); err != nil {
7834 return err
7835 }
7836
7837 // t.Branch (string) (string)
7838 if len("branch") > 1000000 {
7839 return xerrors.Errorf("Value in field \"branch\" was too long")
7840 }
7841
7842 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
7843 return err
7844 }
7845 if _, err := cw.WriteString(string("branch")); err != nil {
7846 return err
7847 }
7848
7849 if len(t.Branch) > 1000000 {
7850 return xerrors.Errorf("Value in field t.Branch was too long")
7851 }
7852
7853 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
7854 return err
7855 }
7856 if _, err := cw.WriteString(string(t.Branch)); err != nil {
7857 return err
7858 }
7859 return nil
7860}
7861
7862func (t *RepoPull_Target) UnmarshalCBOR(r io.Reader) (err error) {
7863 *t = RepoPull_Target{}
7864
7865 cr := cbg.NewCborReader(r)
7866
7867 maj, extra, err := cr.ReadHeader()
7868 if err != nil {
7869 return err
7870 }
7871 defer func() {
7872 if err == io.EOF {
7873 err = io.ErrUnexpectedEOF
7874 }
7875 }()
7876
7877 if maj != cbg.MajMap {
7878 return fmt.Errorf("cbor input should be of type map")
7879 }
7880
7881 if extra > cbg.MaxLength {
7882 return fmt.Errorf("RepoPull_Target: map struct too large (%d)", extra)
7883 }
7884
7885 n := extra
7886
7887 nameBuf := make([]byte, 6)
7888 for i := uint64(0); i < n; i++ {
7889 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7890 if err != nil {
7891 return err
7892 }
7893
7894 if !ok {
7895 // Field doesn't exist on this type, so ignore it
7896 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7897 return err
7898 }
7899 continue
7900 }
7901
7902 switch string(nameBuf[:nameLen]) {
7903 // t.Repo (string) (string)
7904 case "repo":
7905
7906 {
7907 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7908 if err != nil {
7909 return err
7910 }
7911
7912 t.Repo = string(sval)
7913 }
7914 // t.Branch (string) (string)
7915 case "branch":
7916
7917 {
7918 sval, err := cbg.ReadStringWithMax(cr, 1000000)
7919 if err != nil {
7920 return err
7921 }
7922
7923 t.Branch = string(sval)
7924 }
7925
7926 default:
7927 // Field doesn't exist on this type, so ignore it
7928 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7929 return err
7930 }
7931 }
7932 }
7933
7934 return nil
7935}
7936func (t *Spindle) MarshalCBOR(w io.Writer) error {
7937 if t == nil {
7938 _, err := w.Write(cbg.CborNull)
7939 return err
7940 }
7941
7942 cw := cbg.NewCborWriter(w)
7943
7944 if _, err := cw.Write([]byte{162}); err != nil {
7945 return err
7946 }
7947
7948 // t.LexiconTypeID (string) (string)
7949 if len("$type") > 1000000 {
7950 return xerrors.Errorf("Value in field \"$type\" was too long")
7951 }
7952
7953 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7954 return err
7955 }
7956 if _, err := cw.WriteString(string("$type")); err != nil {
7957 return err
7958 }
7959
7960 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle"))); err != nil {
7961 return err
7962 }
7963 if _, err := cw.WriteString(string("sh.tangled.spindle")); err != nil {
7964 return err
7965 }
7966
7967 // t.CreatedAt (string) (string)
7968 if len("createdAt") > 1000000 {
7969 return xerrors.Errorf("Value in field \"createdAt\" was too long")
7970 }
7971
7972 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7973 return err
7974 }
7975 if _, err := cw.WriteString(string("createdAt")); err != nil {
7976 return err
7977 }
7978
7979 if len(t.CreatedAt) > 1000000 {
7980 return xerrors.Errorf("Value in field t.CreatedAt was too long")
7981 }
7982
7983 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7984 return err
7985 }
7986 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7987 return err
7988 }
7989 return nil
7990}
7991
7992func (t *Spindle) UnmarshalCBOR(r io.Reader) (err error) {
7993 *t = Spindle{}
7994
7995 cr := cbg.NewCborReader(r)
7996
7997 maj, extra, err := cr.ReadHeader()
7998 if err != nil {
7999 return err
8000 }
8001 defer func() {
8002 if err == io.EOF {
8003 err = io.ErrUnexpectedEOF
8004 }
8005 }()
8006
8007 if maj != cbg.MajMap {
8008 return fmt.Errorf("cbor input should be of type map")
8009 }
8010
8011 if extra > cbg.MaxLength {
8012 return fmt.Errorf("Spindle: map struct too large (%d)", extra)
8013 }
8014
8015 n := extra
8016
8017 nameBuf := make([]byte, 9)
8018 for i := uint64(0); i < n; i++ {
8019 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8020 if err != nil {
8021 return err
8022 }
8023
8024 if !ok {
8025 // Field doesn't exist on this type, so ignore it
8026 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8027 return err
8028 }
8029 continue
8030 }
8031
8032 switch string(nameBuf[:nameLen]) {
8033 // t.LexiconTypeID (string) (string)
8034 case "$type":
8035
8036 {
8037 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8038 if err != nil {
8039 return err
8040 }
8041
8042 t.LexiconTypeID = string(sval)
8043 }
8044 // t.CreatedAt (string) (string)
8045 case "createdAt":
8046
8047 {
8048 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8049 if err != nil {
8050 return err
8051 }
8052
8053 t.CreatedAt = string(sval)
8054 }
8055
8056 default:
8057 // Field doesn't exist on this type, so ignore it
8058 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8059 return err
8060 }
8061 }
8062 }
8063
8064 return nil
8065}
8066func (t *SpindleMember) MarshalCBOR(w io.Writer) error {
8067 if t == nil {
8068 _, err := w.Write(cbg.CborNull)
8069 return err
8070 }
8071
8072 cw := cbg.NewCborWriter(w)
8073
8074 if _, err := cw.Write([]byte{164}); err != nil {
8075 return err
8076 }
8077
8078 // t.LexiconTypeID (string) (string)
8079 if len("$type") > 1000000 {
8080 return xerrors.Errorf("Value in field \"$type\" was too long")
8081 }
8082
8083 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8084 return err
8085 }
8086 if _, err := cw.WriteString(string("$type")); err != nil {
8087 return err
8088 }
8089
8090 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle.member"))); err != nil {
8091 return err
8092 }
8093 if _, err := cw.WriteString(string("sh.tangled.spindle.member")); err != nil {
8094 return err
8095 }
8096
8097 // t.Subject (string) (string)
8098 if len("subject") > 1000000 {
8099 return xerrors.Errorf("Value in field \"subject\" was too long")
8100 }
8101
8102 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
8103 return err
8104 }
8105 if _, err := cw.WriteString(string("subject")); err != nil {
8106 return err
8107 }
8108
8109 if len(t.Subject) > 1000000 {
8110 return xerrors.Errorf("Value in field t.Subject was too long")
8111 }
8112
8113 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
8114 return err
8115 }
8116 if _, err := cw.WriteString(string(t.Subject)); err != nil {
8117 return err
8118 }
8119
8120 // t.Instance (string) (string)
8121 if len("instance") > 1000000 {
8122 return xerrors.Errorf("Value in field \"instance\" was too long")
8123 }
8124
8125 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("instance"))); err != nil {
8126 return err
8127 }
8128 if _, err := cw.WriteString(string("instance")); err != nil {
8129 return err
8130 }
8131
8132 if len(t.Instance) > 1000000 {
8133 return xerrors.Errorf("Value in field t.Instance was too long")
8134 }
8135
8136 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Instance))); err != nil {
8137 return err
8138 }
8139 if _, err := cw.WriteString(string(t.Instance)); err != nil {
8140 return err
8141 }
8142
8143 // t.CreatedAt (string) (string)
8144 if len("createdAt") > 1000000 {
8145 return xerrors.Errorf("Value in field \"createdAt\" was too long")
8146 }
8147
8148 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
8149 return err
8150 }
8151 if _, err := cw.WriteString(string("createdAt")); err != nil {
8152 return err
8153 }
8154
8155 if len(t.CreatedAt) > 1000000 {
8156 return xerrors.Errorf("Value in field t.CreatedAt was too long")
8157 }
8158
8159 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
8160 return err
8161 }
8162 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
8163 return err
8164 }
8165 return nil
8166}
8167
8168func (t *SpindleMember) UnmarshalCBOR(r io.Reader) (err error) {
8169 *t = SpindleMember{}
8170
8171 cr := cbg.NewCborReader(r)
8172
8173 maj, extra, err := cr.ReadHeader()
8174 if err != nil {
8175 return err
8176 }
8177 defer func() {
8178 if err == io.EOF {
8179 err = io.ErrUnexpectedEOF
8180 }
8181 }()
8182
8183 if maj != cbg.MajMap {
8184 return fmt.Errorf("cbor input should be of type map")
8185 }
8186
8187 if extra > cbg.MaxLength {
8188 return fmt.Errorf("SpindleMember: map struct too large (%d)", extra)
8189 }
8190
8191 n := extra
8192
8193 nameBuf := make([]byte, 9)
8194 for i := uint64(0); i < n; i++ {
8195 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8196 if err != nil {
8197 return err
8198 }
8199
8200 if !ok {
8201 // Field doesn't exist on this type, so ignore it
8202 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8203 return err
8204 }
8205 continue
8206 }
8207
8208 switch string(nameBuf[:nameLen]) {
8209 // t.LexiconTypeID (string) (string)
8210 case "$type":
8211
8212 {
8213 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8214 if err != nil {
8215 return err
8216 }
8217
8218 t.LexiconTypeID = string(sval)
8219 }
8220 // t.Subject (string) (string)
8221 case "subject":
8222
8223 {
8224 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8225 if err != nil {
8226 return err
8227 }
8228
8229 t.Subject = string(sval)
8230 }
8231 // t.Instance (string) (string)
8232 case "instance":
8233
8234 {
8235 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8236 if err != nil {
8237 return err
8238 }
8239
8240 t.Instance = string(sval)
8241 }
8242 // t.CreatedAt (string) (string)
8243 case "createdAt":
8244
8245 {
8246 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8247 if err != nil {
8248 return err
8249 }
8250
8251 t.CreatedAt = string(sval)
8252 }
8253
8254 default:
8255 // Field doesn't exist on this type, so ignore it
8256 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8257 return err
8258 }
8259 }
8260 }
8261
8262 return nil
8263}
8264func (t *String) MarshalCBOR(w io.Writer) error {
8265 if t == nil {
8266 _, err := w.Write(cbg.CborNull)
8267 return err
8268 }
8269
8270 cw := cbg.NewCborWriter(w)
8271
8272 if _, err := cw.Write([]byte{165}); err != nil {
8273 return err
8274 }
8275
8276 // t.LexiconTypeID (string) (string)
8277 if len("$type") > 1000000 {
8278 return xerrors.Errorf("Value in field \"$type\" was too long")
8279 }
8280
8281 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8282 return err
8283 }
8284 if _, err := cw.WriteString(string("$type")); err != nil {
8285 return err
8286 }
8287
8288 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.string"))); err != nil {
8289 return err
8290 }
8291 if _, err := cw.WriteString(string("sh.tangled.string")); err != nil {
8292 return err
8293 }
8294
8295 // t.Contents (string) (string)
8296 if len("contents") > 1000000 {
8297 return xerrors.Errorf("Value in field \"contents\" was too long")
8298 }
8299
8300 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("contents"))); err != nil {
8301 return err
8302 }
8303 if _, err := cw.WriteString(string("contents")); err != nil {
8304 return err
8305 }
8306
8307 if len(t.Contents) > 1000000 {
8308 return xerrors.Errorf("Value in field t.Contents was too long")
8309 }
8310
8311 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Contents))); err != nil {
8312 return err
8313 }
8314 if _, err := cw.WriteString(string(t.Contents)); err != nil {
8315 return err
8316 }
8317
8318 // t.Filename (string) (string)
8319 if len("filename") > 1000000 {
8320 return xerrors.Errorf("Value in field \"filename\" was too long")
8321 }
8322
8323 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("filename"))); err != nil {
8324 return err
8325 }
8326 if _, err := cw.WriteString(string("filename")); err != nil {
8327 return err
8328 }
8329
8330 if len(t.Filename) > 1000000 {
8331 return xerrors.Errorf("Value in field t.Filename was too long")
8332 }
8333
8334 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Filename))); err != nil {
8335 return err
8336 }
8337 if _, err := cw.WriteString(string(t.Filename)); err != nil {
8338 return err
8339 }
8340
8341 // t.CreatedAt (string) (string)
8342 if len("createdAt") > 1000000 {
8343 return xerrors.Errorf("Value in field \"createdAt\" was too long")
8344 }
8345
8346 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
8347 return err
8348 }
8349 if _, err := cw.WriteString(string("createdAt")); err != nil {
8350 return err
8351 }
8352
8353 if len(t.CreatedAt) > 1000000 {
8354 return xerrors.Errorf("Value in field t.CreatedAt was too long")
8355 }
8356
8357 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
8358 return err
8359 }
8360 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
8361 return err
8362 }
8363
8364 // t.Description (string) (string)
8365 if len("description") > 1000000 {
8366 return xerrors.Errorf("Value in field \"description\" was too long")
8367 }
8368
8369 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
8370 return err
8371 }
8372 if _, err := cw.WriteString(string("description")); err != nil {
8373 return err
8374 }
8375
8376 if len(t.Description) > 1000000 {
8377 return xerrors.Errorf("Value in field t.Description was too long")
8378 }
8379
8380 if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil {
8381 return err
8382 }
8383 if _, err := cw.WriteString(string(t.Description)); err != nil {
8384 return err
8385 }
8386 return nil
8387}
8388
8389func (t *String) UnmarshalCBOR(r io.Reader) (err error) {
8390 *t = String{}
8391
8392 cr := cbg.NewCborReader(r)
8393
8394 maj, extra, err := cr.ReadHeader()
8395 if err != nil {
8396 return err
8397 }
8398 defer func() {
8399 if err == io.EOF {
8400 err = io.ErrUnexpectedEOF
8401 }
8402 }()
8403
8404 if maj != cbg.MajMap {
8405 return fmt.Errorf("cbor input should be of type map")
8406 }
8407
8408 if extra > cbg.MaxLength {
8409 return fmt.Errorf("String: map struct too large (%d)", extra)
8410 }
8411
8412 n := extra
8413
8414 nameBuf := make([]byte, 11)
8415 for i := uint64(0); i < n; i++ {
8416 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8417 if err != nil {
8418 return err
8419 }
8420
8421 if !ok {
8422 // Field doesn't exist on this type, so ignore it
8423 if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8424 return err
8425 }
8426 continue
8427 }
8428
8429 switch string(nameBuf[:nameLen]) {
8430 // t.LexiconTypeID (string) (string)
8431 case "$type":
8432
8433 {
8434 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8435 if err != nil {
8436 return err
8437 }
8438
8439 t.LexiconTypeID = string(sval)
8440 }
8441 // t.Contents (string) (string)
8442 case "contents":
8443
8444 {
8445 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8446 if err != nil {
8447 return err
8448 }
8449
8450 t.Contents = string(sval)
8451 }
8452 // t.Filename (string) (string)
8453 case "filename":
8454
8455 {
8456 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8457 if err != nil {
8458 return err
8459 }
8460
8461 t.Filename = string(sval)
8462 }
8463 // t.CreatedAt (string) (string)
8464 case "createdAt":
8465
8466 {
8467 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8468 if err != nil {
8469 return err
8470 }
8471
8472 t.CreatedAt = string(sval)
8473 }
8474 // t.Description (string) (string)
8475 case "description":
8476
8477 {
8478 sval, err := cbg.ReadStringWithMax(cr, 1000000)
8479 if err != nil {
8480 return err
8481 }
8482
8483 t.Description = string(sval)
8484 }
8485
8486 default:
8487 // Field doesn't exist on this type, so ignore it
8488 if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8489 return err
8490 }
8491 }
8492 }
8493
8494 return nil
8495}