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