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