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