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