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