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