···
1502
-
func (t *GitRefUpdate_LangBreakdown) MarshalCBOR(w io.Writer) error {
1502
+
func (t *GitRefUpdate_IndividualLanguageSize) MarshalCBOR(w io.Writer) error {
_, err := w.Write(cbg.CborNull)
cw := cbg.NewCborWriter(w)
1511
-
if t.Inputs == nil {
1510
+
if _, err := cw.Write([]byte{162}); err != nil {
1515
-
if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1514
+
// t.Lang (string) (string)
1515
+
if len("lang") > 1000000 {
1516
+
return xerrors.Errorf("Value in field \"lang\" was too long")
1519
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil {
1522
+
if _, err := cw.WriteString(string("lang")); err != nil {
1519
-
// t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice)
1520
-
if t.Inputs != nil {
1526
+
if len(t.Lang) > 1000000 {
1527
+
return xerrors.Errorf("Value in field t.Lang was too long")
1522
-
if len("inputs") > 1000000 {
1523
-
return xerrors.Errorf("Value in field \"inputs\" was too long")
1530
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil {
1533
+
if _, err := cw.WriteString(string(t.Lang)); err != nil {
1526
-
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
1529
-
if _, err := cw.WriteString(string("inputs")); err != nil {
1537
+
// t.Size (int64) (int64)
1538
+
if len("size") > 1000000 {
1539
+
return xerrors.Errorf("Value in field \"size\" was too long")
1533
-
if len(t.Inputs) > 8192 {
1534
-
return xerrors.Errorf("Slice value in field t.Inputs was too long")
1542
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil {
1545
+
if _, err := cw.WriteString(string("size")); err != nil {
1537
-
if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
1550
+
if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil {
1540
-
for _, v := range t.Inputs {
1541
-
if err := v.MarshalCBOR(cw); err != nil {
1554
+
if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); err != nil {
1550
-
func (t *GitRefUpdate_LangBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
1551
-
*t = GitRefUpdate_LangBreakdown{}
1562
+
func (t *GitRefUpdate_IndividualLanguageSize) UnmarshalCBOR(r io.Reader) (err error) {
1563
+
*t = GitRefUpdate_IndividualLanguageSize{}
cr := cbg.NewCborReader(r)
···
if extra > cbg.MaxLength {
1570
-
return fmt.Errorf("GitRefUpdate_LangBreakdown: map struct too large (%d)", extra)
1582
+
return fmt.Errorf("GitRefUpdate_IndividualLanguageSize: map struct too large (%d)", extra)
1575
-
nameBuf := make([]byte, 6)
1587
+
nameBuf := make([]byte, 4)
for i := uint64(0); i < n; i++ {
nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
···
switch string(nameBuf[:nameLen]) {
1591
-
// t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice)
1594
-
maj, extra, err = cr.ReadHeader()
1600
-
return fmt.Errorf("t.Inputs: array too large (%d)", extra)
1603
+
// t.Lang (string) (string)
1603
-
if maj != cbg.MajArray {
1604
-
return fmt.Errorf("expected cbor array")
1607
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
1608
-
t.Inputs = make([]*GitRefUpdate_IndividualLanguageSize, extra)
1612
+
t.Lang = string(sval)
1611
-
for i := 0; i < int(extra); i++ {
1622
-
b, err := cr.ReadByte()
1626
-
if b != cbg.CborNull[0] {
1627
-
if err := cr.UnreadByte(); err != nil {
1630
-
t.Inputs[i] = new(GitRefUpdate_IndividualLanguageSize)
1631
-
if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
1632
-
return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
1614
+
// t.Size (int64) (int64)
1617
+
maj, extra, err := cr.ReadHeader()
1623
+
case cbg.MajUnsignedInt:
1624
+
extraI = int64(extra)
1626
+
return fmt.Errorf("int64 positive overflow")
1628
+
case cbg.MajNegativeInt:
1629
+
extraI = int64(extra)
1631
+
return fmt.Errorf("int64 negative overflow")
1633
+
extraI = -1 - extraI
1635
+
return fmt.Errorf("wrong type for int64 field: %d", maj)
1638
+
t.Size = int64(extraI)
···
1651
-
func (t *GitRefUpdate_IndividualLanguageSize) MarshalCBOR(w io.Writer) error {
1651
+
func (t *GitRefUpdate_LangBreakdown) MarshalCBOR(w io.Writer) error {
_, err := w.Write(cbg.CborNull)
cw := cbg.NewCborWriter(w)
1659
-
if _, err := cw.Write([]byte{162}); err != nil {
1663
-
// t.Lang (string) (string)
1664
-
if len("lang") > 1000000 {
1665
-
return xerrors.Errorf("Value in field \"lang\" was too long")
1660
+
if t.Inputs == nil {
1668
-
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil {
1671
-
if _, err := cw.WriteString(string("lang")); err != nil {
1664
+
if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1675
-
if len(t.Lang) > 1000000 {
1676
-
return xerrors.Errorf("Value in field t.Lang was too long")
1668
+
// t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice)
1669
+
if t.Inputs != nil {
1679
-
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil {
1682
-
if _, err := cw.WriteString(string(t.Lang)); err != nil {
1671
+
if len("inputs") > 1000000 {
1672
+
return xerrors.Errorf("Value in field \"inputs\" was too long")
1686
-
// t.Size (int64) (int64)
1687
-
if len("size") > 1000000 {
1688
-
return xerrors.Errorf("Value in field \"size\" was too long")
1675
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
1678
+
if _, err := cw.WriteString(string("inputs")); err != nil {
1691
-
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil {
1694
-
if _, err := cw.WriteString(string("size")); err != nil {
1682
+
if len(t.Inputs) > 8192 {
1683
+
return xerrors.Errorf("Slice value in field t.Inputs was too long")
1699
-
if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil {
1686
+
if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
1703
-
if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); err != nil {
1689
+
for _, v := range t.Inputs {
1690
+
if err := v.MarshalCBOR(cw); err != nil {
1711
-
func (t *GitRefUpdate_IndividualLanguageSize) UnmarshalCBOR(r io.Reader) (err error) {
1712
-
*t = GitRefUpdate_IndividualLanguageSize{}
1699
+
func (t *GitRefUpdate_LangBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
1700
+
*t = GitRefUpdate_LangBreakdown{}
cr := cbg.NewCborReader(r)
···
if extra > cbg.MaxLength {
1731
-
return fmt.Errorf("GitRefUpdate_IndividualLanguageSize: map struct too large (%d)", extra)
1719
+
return fmt.Errorf("GitRefUpdate_LangBreakdown: map struct too large (%d)", extra)
1736
-
nameBuf := make([]byte, 4)
1724
+
nameBuf := make([]byte, 6)
for i := uint64(0); i < n; i++ {
nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
···
switch string(nameBuf[:nameLen]) {
1752
-
// t.Lang (string) (string)
1740
+
// t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice)
1756
-
sval, err := cbg.ReadStringWithMax(cr, 1000000)
1743
+
maj, extra, err = cr.ReadHeader()
1761
-
t.Lang = string(sval)
1749
+
return fmt.Errorf("t.Inputs: array too large (%d)", extra)
1763
-
// t.Size (int64) (int64)
1766
-
maj, extra, err := cr.ReadHeader()
1772
-
case cbg.MajUnsignedInt:
1773
-
extraI = int64(extra)
1775
-
return fmt.Errorf("int64 positive overflow")
1777
-
case cbg.MajNegativeInt:
1778
-
extraI = int64(extra)
1780
-
return fmt.Errorf("int64 negative overflow")
1752
+
if maj != cbg.MajArray {
1753
+
return fmt.Errorf("expected cbor array")
1757
+
t.Inputs = make([]*GitRefUpdate_IndividualLanguageSize, extra)
1760
+
for i := 0; i < int(extra); i++ {
1771
+
b, err := cr.ReadByte()
1775
+
if b != cbg.CborNull[0] {
1776
+
if err := cr.UnreadByte(); err != nil {
1779
+
t.Inputs[i] = new(GitRefUpdate_IndividualLanguageSize)
1780
+
if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
1781
+
return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
1782
-
extraI = -1 - extraI
1784
-
return fmt.Errorf("wrong type for int64 field: %d", maj)
1787
-
t.Size = int64(extraI)
···
t.CreatedAt = string(sval)
2463
+
// Field doesn't exist on this type, so ignore it
2464
+
if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2472
+
func (t *LabelDefinition) MarshalCBOR(w io.Writer) error {
2474
+
_, err := w.Write(cbg.CborNull)
2478
+
cw := cbg.NewCborWriter(w)
2481
+
if t.Color == nil {
2485
+
if t.Multiple == nil {
2489
+
if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2493
+
// t.Name (string) (string)
2494
+
if len("name") > 1000000 {
2495
+
return xerrors.Errorf("Value in field \"name\" was too long")
2498
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
2501
+
if _, err := cw.WriteString(string("name")); err != nil {
2505
+
if len(t.Name) > 1000000 {
2506
+
return xerrors.Errorf("Value in field t.Name was too long")
2509
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
2512
+
if _, err := cw.WriteString(string(t.Name)); err != nil {
2516
+
// t.LexiconTypeID (string) (string)
2517
+
if len("$type") > 1000000 {
2518
+
return xerrors.Errorf("Value in field \"$type\" was too long")
2521
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2524
+
if _, err := cw.WriteString(string("$type")); err != nil {
2528
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.definition"))); err != nil {
2531
+
if _, err := cw.WriteString(string("sh.tangled.label.definition")); err != nil {
2535
+
// t.Color (string) (string)
2536
+
if t.Color != nil {
2538
+
if len("color") > 1000000 {
2539
+
return xerrors.Errorf("Value in field \"color\" was too long")
2542
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("color"))); err != nil {
2545
+
if _, err := cw.WriteString(string("color")); err != nil {
2549
+
if t.Color == nil {
2550
+
if _, err := cw.Write(cbg.CborNull); err != nil {
2554
+
if len(*t.Color) > 1000000 {
2555
+
return xerrors.Errorf("Value in field t.Color was too long")
2558
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Color))); err != nil {
2561
+
if _, err := cw.WriteString(string(*t.Color)); err != nil {
2567
+
// t.Scope ([]string) (slice)
2568
+
if len("scope") > 1000000 {
2569
+
return xerrors.Errorf("Value in field \"scope\" was too long")
2572
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("scope"))); err != nil {
2575
+
if _, err := cw.WriteString(string("scope")); err != nil {
2579
+
if len(t.Scope) > 8192 {
2580
+
return xerrors.Errorf("Slice value in field t.Scope was too long")
2583
+
if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Scope))); err != nil {
2586
+
for _, v := range t.Scope {
2587
+
if len(v) > 1000000 {
2588
+
return xerrors.Errorf("Value in field v was too long")
2591
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
2594
+
if _, err := cw.WriteString(string(v)); err != nil {
2600
+
// t.Multiple (bool) (bool)
2601
+
if t.Multiple != nil {
2603
+
if len("multiple") > 1000000 {
2604
+
return xerrors.Errorf("Value in field \"multiple\" was too long")
2607
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("multiple"))); err != nil {
2610
+
if _, err := cw.WriteString(string("multiple")); err != nil {
2614
+
if t.Multiple == nil {
2615
+
if _, err := cw.Write(cbg.CborNull); err != nil {
2619
+
if err := cbg.WriteBool(w, *t.Multiple); err != nil {
2625
+
// t.CreatedAt (string) (string)
2626
+
if len("createdAt") > 1000000 {
2627
+
return xerrors.Errorf("Value in field \"createdAt\" was too long")
2630
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2633
+
if _, err := cw.WriteString(string("createdAt")); err != nil {
2637
+
if len(t.CreatedAt) > 1000000 {
2638
+
return xerrors.Errorf("Value in field t.CreatedAt was too long")
2641
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2644
+
if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2648
+
// t.ValueType (tangled.LabelDefinition_ValueType) (struct)
2649
+
if len("valueType") > 1000000 {
2650
+
return xerrors.Errorf("Value in field \"valueType\" was too long")
2653
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("valueType"))); err != nil {
2656
+
if _, err := cw.WriteString(string("valueType")); err != nil {
2660
+
if err := t.ValueType.MarshalCBOR(cw); err != nil {
2666
+
func (t *LabelDefinition) UnmarshalCBOR(r io.Reader) (err error) {
2667
+
*t = LabelDefinition{}
2669
+
cr := cbg.NewCborReader(r)
2671
+
maj, extra, err := cr.ReadHeader()
2676
+
if err == io.EOF {
2677
+
err = io.ErrUnexpectedEOF
2681
+
if maj != cbg.MajMap {
2682
+
return fmt.Errorf("cbor input should be of type map")
2685
+
if extra > cbg.MaxLength {
2686
+
return fmt.Errorf("LabelDefinition: map struct too large (%d)", extra)
2691
+
nameBuf := make([]byte, 9)
2692
+
for i := uint64(0); i < n; i++ {
2693
+
nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2699
+
// Field doesn't exist on this type, so ignore it
2700
+
if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2706
+
switch string(nameBuf[:nameLen]) {
2707
+
// t.Name (string) (string)
2711
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
2716
+
t.Name = string(sval)
2718
+
// t.LexiconTypeID (string) (string)
2722
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
2727
+
t.LexiconTypeID = string(sval)
2729
+
// t.Color (string) (string)
2733
+
b, err := cr.ReadByte()
2737
+
if b != cbg.CborNull[0] {
2738
+
if err := cr.UnreadByte(); err != nil {
2742
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
2747
+
t.Color = (*string)(&sval)
2750
+
// t.Scope ([]string) (slice)
2753
+
maj, extra, err = cr.ReadHeader()
2759
+
return fmt.Errorf("t.Scope: array too large (%d)", extra)
2762
+
if maj != cbg.MajArray {
2763
+
return fmt.Errorf("expected cbor array")
2767
+
t.Scope = make([]string, extra)
2770
+
for i := 0; i < int(extra); i++ {
2780
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
2785
+
t.Scope[i] = string(sval)
2790
+
// t.Multiple (bool) (bool)
2794
+
b, err := cr.ReadByte()
2798
+
if b != cbg.CborNull[0] {
2799
+
if err := cr.UnreadByte(); err != nil {
2803
+
maj, extra, err = cr.ReadHeader()
2807
+
if maj != cbg.MajOther {
2808
+
return fmt.Errorf("booleans must be major type 7")
2818
+
return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
2823
+
// t.CreatedAt (string) (string)
2827
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
2832
+
t.CreatedAt = string(sval)
2834
+
// t.ValueType (tangled.LabelDefinition_ValueType) (struct)
2839
+
b, err := cr.ReadByte()
2843
+
if b != cbg.CborNull[0] {
2844
+
if err := cr.UnreadByte(); err != nil {
2847
+
t.ValueType = new(LabelDefinition_ValueType)
2848
+
if err := t.ValueType.UnmarshalCBOR(cr); err != nil {
2849
+
return xerrors.Errorf("unmarshaling t.ValueType pointer: %w", err)
2856
+
// Field doesn't exist on this type, so ignore it
2857
+
if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2865
+
func (t *LabelDefinition_ValueType) MarshalCBOR(w io.Writer) error {
2867
+
_, err := w.Write(cbg.CborNull)
2871
+
cw := cbg.NewCborWriter(w)
2874
+
if t.Enum == nil {
2878
+
if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2882
+
// t.Enum ([]string) (slice)
2883
+
if t.Enum != nil {
2885
+
if len("enum") > 1000000 {
2886
+
return xerrors.Errorf("Value in field \"enum\" was too long")
2889
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("enum"))); err != nil {
2892
+
if _, err := cw.WriteString(string("enum")); err != nil {
2896
+
if len(t.Enum) > 8192 {
2897
+
return xerrors.Errorf("Slice value in field t.Enum was too long")
2900
+
if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Enum))); err != nil {
2903
+
for _, v := range t.Enum {
2904
+
if len(v) > 1000000 {
2905
+
return xerrors.Errorf("Value in field v was too long")
2908
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
2911
+
if _, err := cw.WriteString(string(v)); err != nil {
2918
+
// t.Type (string) (string)
2919
+
if len("type") > 1000000 {
2920
+
return xerrors.Errorf("Value in field \"type\" was too long")
2923
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("type"))); err != nil {
2926
+
if _, err := cw.WriteString(string("type")); err != nil {
2930
+
if len(t.Type) > 1000000 {
2931
+
return xerrors.Errorf("Value in field t.Type was too long")
2934
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Type))); err != nil {
2937
+
if _, err := cw.WriteString(string(t.Type)); err != nil {
2941
+
// t.Format (string) (string)
2942
+
if len("format") > 1000000 {
2943
+
return xerrors.Errorf("Value in field \"format\" was too long")
2946
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("format"))); err != nil {
2949
+
if _, err := cw.WriteString(string("format")); err != nil {
2953
+
if len(t.Format) > 1000000 {
2954
+
return xerrors.Errorf("Value in field t.Format was too long")
2957
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Format))); err != nil {
2960
+
if _, err := cw.WriteString(string(t.Format)); err != nil {
2966
+
func (t *LabelDefinition_ValueType) UnmarshalCBOR(r io.Reader) (err error) {
2967
+
*t = LabelDefinition_ValueType{}
2969
+
cr := cbg.NewCborReader(r)
2971
+
maj, extra, err := cr.ReadHeader()
2976
+
if err == io.EOF {
2977
+
err = io.ErrUnexpectedEOF
2981
+
if maj != cbg.MajMap {
2982
+
return fmt.Errorf("cbor input should be of type map")
2985
+
if extra > cbg.MaxLength {
2986
+
return fmt.Errorf("LabelDefinition_ValueType: map struct too large (%d)", extra)
2991
+
nameBuf := make([]byte, 6)
2992
+
for i := uint64(0); i < n; i++ {
2993
+
nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2999
+
// Field doesn't exist on this type, so ignore it
3000
+
if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3006
+
switch string(nameBuf[:nameLen]) {
3007
+
// t.Enum ([]string) (slice)
3010
+
maj, extra, err = cr.ReadHeader()
3016
+
return fmt.Errorf("t.Enum: array too large (%d)", extra)
3019
+
if maj != cbg.MajArray {
3020
+
return fmt.Errorf("expected cbor array")
3024
+
t.Enum = make([]string, extra)
3027
+
for i := 0; i < int(extra); i++ {
3037
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
3042
+
t.Enum[i] = string(sval)
3047
+
// t.Type (string) (string)
3051
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
3056
+
t.Type = string(sval)
3058
+
// t.Format (string) (string)
3062
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
3067
+
t.Format = string(sval)
nel.pet
oppi.li