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