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