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