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