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