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