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