···
cw := cbg.NewCborWriter(w)
679
-
if _, err := cw.Write([]byte{167}); err != nil {
679
+
if _, err := cw.Write([]byte{168}); err != nil {
···
if _, err := cw.WriteString(string(t.Ref)); err != nil {
706
+
// t.Meta (tangled.GitRefUpdate_Meta) (struct)
707
+
if len("meta") > 1000000 {
708
+
return xerrors.Errorf("Value in field \"meta\" was too long")
711
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil {
714
+
if _, err := cw.WriteString(string("meta")); err != nil {
718
+
if err := t.Meta.MarshalCBOR(cw); err != nil {
···
910
+
// t.Meta (tangled.GitRefUpdate_Meta) (struct)
915
+
b, err := cr.ReadByte()
919
+
if b != cbg.CborNull[0] {
920
+
if err := cr.UnreadByte(); err != nil {
923
+
t.Meta = new(GitRefUpdate_Meta)
924
+
if err := t.Meta.UnmarshalCBOR(cr); err != nil {
925
+
return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err)
// t.LexiconTypeID (string) (string)
···
t.CommitterDid = string(sval)
998
+
// Field doesn't exist on this type, so ignore it
999
+
if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1007
+
func (t *GitRefUpdate_Meta) MarshalCBOR(w io.Writer) error {
1009
+
_, err := w.Write(cbg.CborNull)
1013
+
cw := cbg.NewCborWriter(w)
1015
+
if _, err := cw.Write([]byte{162}); err != nil {
1019
+
// t.CommitCount (tangled.GitRefUpdate_Meta_CommitCount) (struct)
1020
+
if len("commitCount") > 1000000 {
1021
+
return xerrors.Errorf("Value in field \"commitCount\" was too long")
1024
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commitCount"))); err != nil {
1027
+
if _, err := cw.WriteString(string("commitCount")); err != nil {
1031
+
if err := t.CommitCount.MarshalCBOR(cw); err != nil {
1035
+
// t.IsDefaultRef (bool) (bool)
1036
+
if len("isDefaultRef") > 1000000 {
1037
+
return xerrors.Errorf("Value in field \"isDefaultRef\" was too long")
1040
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("isDefaultRef"))); err != nil {
1043
+
if _, err := cw.WriteString(string("isDefaultRef")); err != nil {
1047
+
if err := cbg.WriteBool(w, t.IsDefaultRef); err != nil {
1053
+
func (t *GitRefUpdate_Meta) UnmarshalCBOR(r io.Reader) (err error) {
1054
+
*t = GitRefUpdate_Meta{}
1056
+
cr := cbg.NewCborReader(r)
1058
+
maj, extra, err := cr.ReadHeader()
1063
+
if err == io.EOF {
1064
+
err = io.ErrUnexpectedEOF
1068
+
if maj != cbg.MajMap {
1069
+
return fmt.Errorf("cbor input should be of type map")
1072
+
if extra > cbg.MaxLength {
1073
+
return fmt.Errorf("GitRefUpdate_Meta: map struct too large (%d)", extra)
1078
+
nameBuf := make([]byte, 12)
1079
+
for i := uint64(0); i < n; i++ {
1080
+
nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1086
+
// Field doesn't exist on this type, so ignore it
1087
+
if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1093
+
switch string(nameBuf[:nameLen]) {
1094
+
// t.CommitCount (tangled.GitRefUpdate_Meta_CommitCount) (struct)
1095
+
case "commitCount":
1099
+
b, err := cr.ReadByte()
1103
+
if b != cbg.CborNull[0] {
1104
+
if err := cr.UnreadByte(); err != nil {
1107
+
t.CommitCount = new(GitRefUpdate_Meta_CommitCount)
1108
+
if err := t.CommitCount.UnmarshalCBOR(cr); err != nil {
1109
+
return xerrors.Errorf("unmarshaling t.CommitCount pointer: %w", err)
1114
+
// t.IsDefaultRef (bool) (bool)
1115
+
case "isDefaultRef":
1117
+
maj, extra, err = cr.ReadHeader()
1121
+
if maj != cbg.MajOther {
1122
+
return fmt.Errorf("booleans must be major type 7")
1126
+
t.IsDefaultRef = false
1128
+
t.IsDefaultRef = true
1130
+
return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
1134
+
// Field doesn't exist on this type, so ignore it
1135
+
if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1143
+
func (t *GitRefUpdate_Meta_CommitCount) MarshalCBOR(w io.Writer) error {
1145
+
_, err := w.Write(cbg.CborNull)
1149
+
cw := cbg.NewCborWriter(w)
1152
+
if t.ByEmail == nil {
1156
+
if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1160
+
// t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice)
1161
+
if t.ByEmail != nil {
1163
+
if len("byEmail") > 1000000 {
1164
+
return xerrors.Errorf("Value in field \"byEmail\" was too long")
1167
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byEmail"))); err != nil {
1170
+
if _, err := cw.WriteString(string("byEmail")); err != nil {
1174
+
if len(t.ByEmail) > 8192 {
1175
+
return xerrors.Errorf("Slice value in field t.ByEmail was too long")
1178
+
if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ByEmail))); err != nil {
1181
+
for _, v := range t.ByEmail {
1182
+
if err := v.MarshalCBOR(cw); err != nil {
1191
+
func (t *GitRefUpdate_Meta_CommitCount) UnmarshalCBOR(r io.Reader) (err error) {
1192
+
*t = GitRefUpdate_Meta_CommitCount{}
1194
+
cr := cbg.NewCborReader(r)
1196
+
maj, extra, err := cr.ReadHeader()
1201
+
if err == io.EOF {
1202
+
err = io.ErrUnexpectedEOF
1206
+
if maj != cbg.MajMap {
1207
+
return fmt.Errorf("cbor input should be of type map")
1210
+
if extra > cbg.MaxLength {
1211
+
return fmt.Errorf("GitRefUpdate_Meta_CommitCount: map struct too large (%d)", extra)
1216
+
nameBuf := make([]byte, 7)
1217
+
for i := uint64(0); i < n; i++ {
1218
+
nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1224
+
// Field doesn't exist on this type, so ignore it
1225
+
if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1231
+
switch string(nameBuf[:nameLen]) {
1232
+
// t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice)
1235
+
maj, extra, err = cr.ReadHeader()
1241
+
return fmt.Errorf("t.ByEmail: array too large (%d)", extra)
1244
+
if maj != cbg.MajArray {
1245
+
return fmt.Errorf("expected cbor array")
1249
+
t.ByEmail = make([]*GitRefUpdate_Meta_CommitCount_ByEmail_Elem, extra)
1252
+
for i := 0; i < int(extra); i++ {
1263
+
b, err := cr.ReadByte()
1267
+
if b != cbg.CborNull[0] {
1268
+
if err := cr.UnreadByte(); err != nil {
1271
+
t.ByEmail[i] = new(GitRefUpdate_Meta_CommitCount_ByEmail_Elem)
1272
+
if err := t.ByEmail[i].UnmarshalCBOR(cr); err != nil {
1273
+
return xerrors.Errorf("unmarshaling t.ByEmail[i] pointer: %w", err)
1283
+
// Field doesn't exist on this type, so ignore it
1284
+
if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1292
+
func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) MarshalCBOR(w io.Writer) error {
1294
+
_, err := w.Write(cbg.CborNull)
1298
+
cw := cbg.NewCborWriter(w)
1300
+
if _, err := cw.Write([]byte{162}); err != nil {
1304
+
// t.Count (int64) (int64)
1305
+
if len("count") > 1000000 {
1306
+
return xerrors.Errorf("Value in field \"count\" was too long")
1309
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("count"))); err != nil {
1312
+
if _, err := cw.WriteString(string("count")); err != nil {
1317
+
if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Count)); err != nil {
1321
+
if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Count-1)); err != nil {
1326
+
// t.Email (string) (string)
1327
+
if len("email") > 1000000 {
1328
+
return xerrors.Errorf("Value in field \"email\" was too long")
1331
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("email"))); err != nil {
1334
+
if _, err := cw.WriteString(string("email")); err != nil {
1338
+
if len(t.Email) > 1000000 {
1339
+
return xerrors.Errorf("Value in field t.Email was too long")
1342
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Email))); err != nil {
1345
+
if _, err := cw.WriteString(string(t.Email)); err != nil {
1351
+
func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) UnmarshalCBOR(r io.Reader) (err error) {
1352
+
*t = GitRefUpdate_Meta_CommitCount_ByEmail_Elem{}
1354
+
cr := cbg.NewCborReader(r)
1356
+
maj, extra, err := cr.ReadHeader()
1361
+
if err == io.EOF {
1362
+
err = io.ErrUnexpectedEOF
1366
+
if maj != cbg.MajMap {
1367
+
return fmt.Errorf("cbor input should be of type map")
1370
+
if extra > cbg.MaxLength {
1371
+
return fmt.Errorf("GitRefUpdate_Meta_CommitCount_ByEmail_Elem: map struct too large (%d)", extra)
1376
+
nameBuf := make([]byte, 5)
1377
+
for i := uint64(0); i < n; i++ {
1378
+
nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1384
+
// Field doesn't exist on this type, so ignore it
1385
+
if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1391
+
switch string(nameBuf[:nameLen]) {
1392
+
// t.Count (int64) (int64)
1395
+
maj, extra, err := cr.ReadHeader()
1401
+
case cbg.MajUnsignedInt:
1402
+
extraI = int64(extra)
1404
+
return fmt.Errorf("int64 positive overflow")
1406
+
case cbg.MajNegativeInt:
1407
+
extraI = int64(extra)
1409
+
return fmt.Errorf("int64 negative overflow")
1411
+
extraI = -1 - extraI
1413
+
return fmt.Errorf("wrong type for int64 field: %d", maj)
1416
+
t.Count = int64(extraI)
1418
+
// t.Email (string) (string)
1422
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
1427
+
t.Email = string(sval)
···
1722
-
func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error {
1724
-
_, err := w.Write(cbg.CborNull)
1728
-
cw := cbg.NewCborWriter(w)
1730
-
if _, err := cw.Write([]byte{165}); err != nil {
1734
-
// t.Name (string) (string)
1735
-
if len("name") > 1000000 {
1736
-
return xerrors.Errorf("Value in field \"name\" was too long")
1739
-
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
1742
-
if _, err := cw.WriteString(string("name")); err != nil {
1746
-
if len(t.Name) > 1000000 {
1747
-
return xerrors.Errorf("Value in field t.Name was too long")
1750
-
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
1753
-
if _, err := cw.WriteString(string(t.Name)); err != nil {
1757
-
// t.Clone (tangled.Pipeline_CloneOpts) (struct)
1758
-
if len("clone") > 1000000 {
1759
-
return xerrors.Errorf("Value in field \"clone\" was too long")
1762
-
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil {
1765
-
if _, err := cw.WriteString(string("clone")); err != nil {
1769
-
if err := t.Clone.MarshalCBOR(cw); err != nil {
1773
-
// t.Steps ([]*tangled.Pipeline_Step) (slice)
1774
-
if len("steps") > 1000000 {
1775
-
return xerrors.Errorf("Value in field \"steps\" was too long")
1778
-
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("steps"))); err != nil {
1781
-
if _, err := cw.WriteString(string("steps")); err != nil {
1785
-
if len(t.Steps) > 8192 {
1786
-
return xerrors.Errorf("Slice value in field t.Steps was too long")
1789
-
if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Steps))); err != nil {
1792
-
for _, v := range t.Steps {
1793
-
if err := v.MarshalCBOR(cw); err != nil {
1799
-
// t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice)
1800
-
if len("environment") > 1000000 {
1801
-
return xerrors.Errorf("Value in field \"environment\" was too long")
1804
-
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("environment"))); err != nil {
1807
-
if _, err := cw.WriteString(string("environment")); err != nil {
1811
-
if len(t.Environment) > 8192 {
1812
-
return xerrors.Errorf("Slice value in field t.Environment was too long")
1815
-
if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Environment))); err != nil {
1818
-
for _, v := range t.Environment {
1819
-
if err := v.MarshalCBOR(cw); err != nil {
1825
-
// t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice)
1826
-
if len("dependencies") > 1000000 {
1827
-
return xerrors.Errorf("Value in field \"dependencies\" was too long")
1830
-
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("dependencies"))); err != nil {
1833
-
if _, err := cw.WriteString(string("dependencies")); err != nil {
1837
-
if len(t.Dependencies) > 8192 {
1838
-
return xerrors.Errorf("Slice value in field t.Dependencies was too long")
1841
-
if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Dependencies))); err != nil {
1844
-
for _, v := range t.Dependencies {
1845
-
if err := v.MarshalCBOR(cw); err != nil {
1853
-
func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) {
1854
-
*t = Pipeline_Workflow{}
1856
-
cr := cbg.NewCborReader(r)
1858
-
maj, extra, err := cr.ReadHeader()
1863
-
if err == io.EOF {
1864
-
err = io.ErrUnexpectedEOF
1868
-
if maj != cbg.MajMap {
1869
-
return fmt.Errorf("cbor input should be of type map")
1872
-
if extra > cbg.MaxLength {
1873
-
return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra)
1878
-
nameBuf := make([]byte, 12)
1879
-
for i := uint64(0); i < n; i++ {
1880
-
nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1886
-
// Field doesn't exist on this type, so ignore it
1887
-
if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1893
-
switch string(nameBuf[:nameLen]) {
1894
-
// t.Name (string) (string)
1898
-
sval, err := cbg.ReadStringWithMax(cr, 1000000)
1903
-
t.Name = string(sval)
1905
-
// t.Clone (tangled.Pipeline_CloneOpts) (struct)
1910
-
b, err := cr.ReadByte()
1914
-
if b != cbg.CborNull[0] {
1915
-
if err := cr.UnreadByte(); err != nil {
1918
-
t.Clone = new(Pipeline_CloneOpts)
1919
-
if err := t.Clone.UnmarshalCBOR(cr); err != nil {
1920
-
return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err)
1925
-
// t.Steps ([]*tangled.Pipeline_Step) (slice)
1928
-
maj, extra, err = cr.ReadHeader()
1934
-
return fmt.Errorf("t.Steps: array too large (%d)", extra)
1937
-
if maj != cbg.MajArray {
1938
-
return fmt.Errorf("expected cbor array")
1942
-
t.Steps = make([]*Pipeline_Step, extra)
1945
-
for i := 0; i < int(extra); i++ {
1956
-
b, err := cr.ReadByte()
1960
-
if b != cbg.CborNull[0] {
1961
-
if err := cr.UnreadByte(); err != nil {
1964
-
t.Steps[i] = new(Pipeline_Step)
1965
-
if err := t.Steps[i].UnmarshalCBOR(cr); err != nil {
1966
-
return xerrors.Errorf("unmarshaling t.Steps[i] pointer: %w", err)
1974
-
// t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice)
1975
-
case "environment":
1977
-
maj, extra, err = cr.ReadHeader()
1983
-
return fmt.Errorf("t.Environment: array too large (%d)", extra)
1986
-
if maj != cbg.MajArray {
1987
-
return fmt.Errorf("expected cbor array")
1991
-
t.Environment = make([]*Pipeline_Workflow_Environment_Elem, extra)
1994
-
for i := 0; i < int(extra); i++ {
2005
-
b, err := cr.ReadByte()
2009
-
if b != cbg.CborNull[0] {
2010
-
if err := cr.UnreadByte(); err != nil {
2013
-
t.Environment[i] = new(Pipeline_Workflow_Environment_Elem)
2014
-
if err := t.Environment[i].UnmarshalCBOR(cr); err != nil {
2015
-
return xerrors.Errorf("unmarshaling t.Environment[i] pointer: %w", err)
2023
-
// t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice)
2024
-
case "dependencies":
2026
-
maj, extra, err = cr.ReadHeader()
2032
-
return fmt.Errorf("t.Dependencies: array too large (%d)", extra)
2035
-
if maj != cbg.MajArray {
2036
-
return fmt.Errorf("expected cbor array")
2040
-
t.Dependencies = make([]Pipeline_Dependencies_Elem, extra)
2043
-
for i := 0; i < int(extra); i++ {
2054
-
if err := t.Dependencies[i].UnmarshalCBOR(cr); err != nil {
2055
-
return xerrors.Errorf("unmarshaling t.Dependencies[i]: %w", err)
2064
-
// Field doesn't exist on this type, so ignore it
2065
-
if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2073
-
func (t *Pipeline_Workflow_Environment_Elem) MarshalCBOR(w io.Writer) error {
2075
-
_, err := w.Write(cbg.CborNull)
2079
-
cw := cbg.NewCborWriter(w)
2081
-
if _, err := cw.Write([]byte{162}); err != nil {
2085
-
// t.Key (string) (string)
2086
-
if len("key") > 1000000 {
2087
-
return xerrors.Errorf("Value in field \"key\" was too long")
2090
-
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
2093
-
if _, err := cw.WriteString(string("key")); err != nil {
2097
-
if len(t.Key) > 1000000 {
2098
-
return xerrors.Errorf("Value in field t.Key was too long")
2101
-
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
2104
-
if _, err := cw.WriteString(string(t.Key)); err != nil {
2108
-
// t.Value (string) (string)
2109
-
if len("value") > 1000000 {
2110
-
return xerrors.Errorf("Value in field \"value\" was too long")
2113
-
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
2116
-
if _, err := cw.WriteString(string("value")); err != nil {
2120
-
if len(t.Value) > 1000000 {
2121
-
return xerrors.Errorf("Value in field t.Value was too long")
2124
-
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
2127
-
if _, err := cw.WriteString(string(t.Value)); err != nil {
2133
-
func (t *Pipeline_Workflow_Environment_Elem) UnmarshalCBOR(r io.Reader) (err error) {
2134
-
*t = Pipeline_Workflow_Environment_Elem{}
2136
-
cr := cbg.NewCborReader(r)
2138
-
maj, extra, err := cr.ReadHeader()
2143
-
if err == io.EOF {
2144
-
err = io.ErrUnexpectedEOF
2148
-
if maj != cbg.MajMap {
2149
-
return fmt.Errorf("cbor input should be of type map")
2152
-
if extra > cbg.MaxLength {
2153
-
return fmt.Errorf("Pipeline_Workflow_Environment_Elem: map struct too large (%d)", extra)
2158
-
nameBuf := make([]byte, 5)
2159
-
for i := uint64(0); i < n; i++ {
2160
-
nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2166
-
// Field doesn't exist on this type, so ignore it
2167
-
if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2173
-
switch string(nameBuf[:nameLen]) {
2174
-
// t.Key (string) (string)
2178
-
sval, err := cbg.ReadStringWithMax(cr, 1000000)
2183
-
t.Key = string(sval)
2185
-
// t.Value (string) (string)
2189
-
sval, err := cbg.ReadStringWithMax(cr, 1000000)
2194
-
t.Value = string(sval)
2198
-
// Field doesn't exist on this type, so ignore it
2199
-
if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
func (t *Pipeline_Dependencies_Elem) MarshalCBOR(w io.Writer) error {
_, err := w.Write(cbg.CborNull)
···
t.DefaultBranch = string(sval)
3610
+
// Field doesn't exist on this type, so ignore it
3611
+
if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3619
+
func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error {
3621
+
_, err := w.Write(cbg.CborNull)
3625
+
cw := cbg.NewCborWriter(w)
3627
+
if _, err := cw.Write([]byte{165}); err != nil {
3631
+
// t.Name (string) (string)
3632
+
if len("name") > 1000000 {
3633
+
return xerrors.Errorf("Value in field \"name\" was too long")
3636
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
3639
+
if _, err := cw.WriteString(string("name")); err != nil {
3643
+
if len(t.Name) > 1000000 {
3644
+
return xerrors.Errorf("Value in field t.Name was too long")
3647
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
3650
+
if _, err := cw.WriteString(string(t.Name)); err != nil {
3654
+
// t.Clone (tangled.Pipeline_CloneOpts) (struct)
3655
+
if len("clone") > 1000000 {
3656
+
return xerrors.Errorf("Value in field \"clone\" was too long")
3659
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil {
3662
+
if _, err := cw.WriteString(string("clone")); err != nil {
3666
+
if err := t.Clone.MarshalCBOR(cw); err != nil {
3670
+
// t.Steps ([]*tangled.Pipeline_Step) (slice)
3671
+
if len("steps") > 1000000 {
3672
+
return xerrors.Errorf("Value in field \"steps\" was too long")
3675
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("steps"))); err != nil {
3678
+
if _, err := cw.WriteString(string("steps")); err != nil {
3682
+
if len(t.Steps) > 8192 {
3683
+
return xerrors.Errorf("Slice value in field t.Steps was too long")
3686
+
if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Steps))); err != nil {
3689
+
for _, v := range t.Steps {
3690
+
if err := v.MarshalCBOR(cw); err != nil {
3696
+
// t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice)
3697
+
if len("environment") > 1000000 {
3698
+
return xerrors.Errorf("Value in field \"environment\" was too long")
3701
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("environment"))); err != nil {
3704
+
if _, err := cw.WriteString(string("environment")); err != nil {
3708
+
if len(t.Environment) > 8192 {
3709
+
return xerrors.Errorf("Slice value in field t.Environment was too long")
3712
+
if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Environment))); err != nil {
3715
+
for _, v := range t.Environment {
3716
+
if err := v.MarshalCBOR(cw); err != nil {
3722
+
// t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice)
3723
+
if len("dependencies") > 1000000 {
3724
+
return xerrors.Errorf("Value in field \"dependencies\" was too long")
3727
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("dependencies"))); err != nil {
3730
+
if _, err := cw.WriteString(string("dependencies")); err != nil {
3734
+
if len(t.Dependencies) > 8192 {
3735
+
return xerrors.Errorf("Slice value in field t.Dependencies was too long")
3738
+
if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Dependencies))); err != nil {
3741
+
for _, v := range t.Dependencies {
3742
+
if err := v.MarshalCBOR(cw); err != nil {
3750
+
func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) {
3751
+
*t = Pipeline_Workflow{}
3753
+
cr := cbg.NewCborReader(r)
3755
+
maj, extra, err := cr.ReadHeader()
3760
+
if err == io.EOF {
3761
+
err = io.ErrUnexpectedEOF
3765
+
if maj != cbg.MajMap {
3766
+
return fmt.Errorf("cbor input should be of type map")
3769
+
if extra > cbg.MaxLength {
3770
+
return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra)
3775
+
nameBuf := make([]byte, 12)
3776
+
for i := uint64(0); i < n; i++ {
3777
+
nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3783
+
// Field doesn't exist on this type, so ignore it
3784
+
if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3790
+
switch string(nameBuf[:nameLen]) {
3791
+
// t.Name (string) (string)
3795
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
3800
+
t.Name = string(sval)
3802
+
// t.Clone (tangled.Pipeline_CloneOpts) (struct)
3807
+
b, err := cr.ReadByte()
3811
+
if b != cbg.CborNull[0] {
3812
+
if err := cr.UnreadByte(); err != nil {
3815
+
t.Clone = new(Pipeline_CloneOpts)
3816
+
if err := t.Clone.UnmarshalCBOR(cr); err != nil {
3817
+
return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err)
3822
+
// t.Steps ([]*tangled.Pipeline_Step) (slice)
3825
+
maj, extra, err = cr.ReadHeader()
3831
+
return fmt.Errorf("t.Steps: array too large (%d)", extra)
3834
+
if maj != cbg.MajArray {
3835
+
return fmt.Errorf("expected cbor array")
3839
+
t.Steps = make([]*Pipeline_Step, extra)
3842
+
for i := 0; i < int(extra); i++ {
3853
+
b, err := cr.ReadByte()
3857
+
if b != cbg.CborNull[0] {
3858
+
if err := cr.UnreadByte(); err != nil {
3861
+
t.Steps[i] = new(Pipeline_Step)
3862
+
if err := t.Steps[i].UnmarshalCBOR(cr); err != nil {
3863
+
return xerrors.Errorf("unmarshaling t.Steps[i] pointer: %w", err)
3871
+
// t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice)
3872
+
case "environment":
3874
+
maj, extra, err = cr.ReadHeader()
3880
+
return fmt.Errorf("t.Environment: array too large (%d)", extra)
3883
+
if maj != cbg.MajArray {
3884
+
return fmt.Errorf("expected cbor array")
3888
+
t.Environment = make([]*Pipeline_Workflow_Environment_Elem, extra)
3891
+
for i := 0; i < int(extra); i++ {
3902
+
b, err := cr.ReadByte()
3906
+
if b != cbg.CborNull[0] {
3907
+
if err := cr.UnreadByte(); err != nil {
3910
+
t.Environment[i] = new(Pipeline_Workflow_Environment_Elem)
3911
+
if err := t.Environment[i].UnmarshalCBOR(cr); err != nil {
3912
+
return xerrors.Errorf("unmarshaling t.Environment[i] pointer: %w", err)
3920
+
// t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice)
3921
+
case "dependencies":
3923
+
maj, extra, err = cr.ReadHeader()
3929
+
return fmt.Errorf("t.Dependencies: array too large (%d)", extra)
3932
+
if maj != cbg.MajArray {
3933
+
return fmt.Errorf("expected cbor array")
3937
+
t.Dependencies = make([]Pipeline_Dependencies_Elem, extra)
3940
+
for i := 0; i < int(extra); i++ {
3951
+
if err := t.Dependencies[i].UnmarshalCBOR(cr); err != nil {
3952
+
return xerrors.Errorf("unmarshaling t.Dependencies[i]: %w", err)
3961
+
// Field doesn't exist on this type, so ignore it
3962
+
if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3970
+
func (t *Pipeline_Workflow_Environment_Elem) MarshalCBOR(w io.Writer) error {
3972
+
_, err := w.Write(cbg.CborNull)
3976
+
cw := cbg.NewCborWriter(w)
3978
+
if _, err := cw.Write([]byte{162}); err != nil {
3982
+
// t.Key (string) (string)
3983
+
if len("key") > 1000000 {
3984
+
return xerrors.Errorf("Value in field \"key\" was too long")
3987
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
3990
+
if _, err := cw.WriteString(string("key")); err != nil {
3994
+
if len(t.Key) > 1000000 {
3995
+
return xerrors.Errorf("Value in field t.Key was too long")
3998
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
4001
+
if _, err := cw.WriteString(string(t.Key)); err != nil {
4005
+
// t.Value (string) (string)
4006
+
if len("value") > 1000000 {
4007
+
return xerrors.Errorf("Value in field \"value\" was too long")
4010
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
4013
+
if _, err := cw.WriteString(string("value")); err != nil {
4017
+
if len(t.Value) > 1000000 {
4018
+
return xerrors.Errorf("Value in field t.Value was too long")
4021
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
4024
+
if _, err := cw.WriteString(string(t.Value)); err != nil {
4030
+
func (t *Pipeline_Workflow_Environment_Elem) UnmarshalCBOR(r io.Reader) (err error) {
4031
+
*t = Pipeline_Workflow_Environment_Elem{}
4033
+
cr := cbg.NewCborReader(r)
4035
+
maj, extra, err := cr.ReadHeader()
4040
+
if err == io.EOF {
4041
+
err = io.ErrUnexpectedEOF
4045
+
if maj != cbg.MajMap {
4046
+
return fmt.Errorf("cbor input should be of type map")
4049
+
if extra > cbg.MaxLength {
4050
+
return fmt.Errorf("Pipeline_Workflow_Environment_Elem: map struct too large (%d)", extra)
4055
+
nameBuf := make([]byte, 5)
4056
+
for i := uint64(0); i < n; i++ {
4057
+
nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4063
+
// Field doesn't exist on this type, so ignore it
4064
+
if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4070
+
switch string(nameBuf[:nameLen]) {
4071
+
// t.Key (string) (string)
4075
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
4080
+
t.Key = string(sval)
4082
+
// t.Value (string) (string)
4086
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
4091
+
t.Value = string(sval)
julien.rbrt.fr
oppi.li