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