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