+1920 -1790

api/tangled/cbor_gen.go

reviewed

··· 866 866 867 867 return nil 868 868 } 869 869 - func (t *GitRefUpdate) MarshalCBOR(w io.Writer) error { 869 869 + func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) MarshalCBOR(w io.Writer) error { 870 870 if t == nil { 871 871 _, err := w.Write(cbg.CborNull) 872 872 return err ··· 874 874 875 875 cw := cbg.NewCborWriter(w) 876 876 877 877 - if _, err := cw.Write([]byte{168}); err != nil { 878 878 - return err 879 879 - } 880 880 - 881 881 - // t.Ref (string) (string) 882 882 - if len("ref") > 1000000 { 883 883 - return xerrors.Errorf("Value in field \"ref\" was too long") 884 884 - } 885 885 - 886 886 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil { 887 887 - return err 888 888 - } 889 889 - if _, err := cw.WriteString(string("ref")); err != nil { 890 890 - return err 891 891 - } 892 892 - 893 893 - if len(t.Ref) > 1000000 { 894 894 - return xerrors.Errorf("Value in field t.Ref was too long") 895 895 - } 896 896 - 897 897 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil { 898 898 - return err 899 899 - } 900 900 - if _, err := cw.WriteString(string(t.Ref)); err != nil { 901 901 - return err 902 902 - } 903 903 - 904 904 - // t.Meta (tangled.GitRefUpdate_Meta) (struct) 905 905 - if len("meta") > 1000000 { 906 906 - return xerrors.Errorf("Value in field \"meta\" was too long") 907 907 - } 908 908 - 909 909 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil { 910 910 - return err 911 911 - } 912 912 - if _, err := cw.WriteString(string("meta")); err != nil { 913 913 - return err 914 914 - } 915 915 - 916 916 - if err := t.Meta.MarshalCBOR(cw); err != nil { 917 917 - return err 918 918 - } 919 919 - 920 920 - // t.LexiconTypeID (string) (string) 921 921 - if len("$type") > 1000000 { 922 922 - return xerrors.Errorf("Value in field \"$type\" was too long") 923 923 - } 924 924 - 925 925 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 926 926 - return err 927 927 - } 928 928 - if _, err := cw.WriteString(string("$type")); err != nil { 929 929 - return err 930 930 - } 931 931 - 932 932 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.git.refUpdate"))); err != nil { 933 933 - return err 934 934 - } 935 935 - if _, err := cw.WriteString(string("sh.tangled.git.refUpdate")); err != nil { 936 936 - return err 937 937 - } 938 938 - 939 939 - // t.NewSha (string) (string) 940 940 - if len("newSha") > 1000000 { 941 941 - return xerrors.Errorf("Value in field \"newSha\" was too long") 942 942 - } 943 943 - 944 944 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil { 945 945 - return err 946 946 - } 947 947 - if _, err := cw.WriteString(string("newSha")); err != nil { 948 948 - return err 949 949 - } 950 950 - 951 951 - if len(t.NewSha) > 1000000 { 952 952 - return xerrors.Errorf("Value in field t.NewSha was too long") 953 953 - } 954 954 - 955 955 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil { 956 956 - return err 957 957 - } 958 958 - if _, err := cw.WriteString(string(t.NewSha)); err != nil { 959 959 - return err 960 960 - } 961 961 - 962 962 - // t.OldSha (string) (string) 963 963 - if len("oldSha") > 1000000 { 964 964 - return xerrors.Errorf("Value in field \"oldSha\" was too long") 965 965 - } 966 966 - 967 967 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil { 968 968 - return err 969 969 - } 970 970 - if _, err := cw.WriteString(string("oldSha")); err != nil { 971 971 - return err 972 972 - } 973 973 - 974 974 - if len(t.OldSha) > 1000000 { 975 975 - return xerrors.Errorf("Value in field t.OldSha was too long") 976 976 - } 977 977 - 978 978 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil { 979 979 - return err 980 980 - } 981 981 - if _, err := cw.WriteString(string(t.OldSha)); err != nil { 982 982 - return err 983 983 - } 984 984 - 985 985 - // t.RepoDid (string) (string) 986 986 - if len("repoDid") > 1000000 { 987 987 - return xerrors.Errorf("Value in field \"repoDid\" was too long") 988 988 - } 989 989 - 990 990 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil { 991 991 - return err 992 992 - } 993 993 - if _, err := cw.WriteString(string("repoDid")); err != nil { 877 877 + if _, err := cw.Write([]byte{162}); err != nil { 994 878 return err 995 879 } 996 880 997 997 - if len(t.RepoDid) > 1000000 { 998 998 - return xerrors.Errorf("Value in field t.RepoDid was too long") 881 881 + // t.Count (int64) (int64) 882 882 + if len("count") > 1000000 { 883 883 + return xerrors.Errorf("Value in field \"count\" was too long") 999 884 } 1000 885 1001 1001 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoDid))); err != nil { 886 886 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("count"))); err != nil { 1002 887 return err 1003 888 } 1004 1004 - if _, err := cw.WriteString(string(t.RepoDid)); err != nil { 889 889 + if _, err := cw.WriteString(string("count")); err != nil { 1005 890 return err 1006 891 } 1007 892 1008 1008 - // t.RepoName (string) (string) 1009 1009 - if len("repoName") > 1000000 { 1010 1010 - return xerrors.Errorf("Value in field \"repoName\" was too long") 1011 1011 - } 1012 1012 - 1013 1013 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoName"))); err != nil { 1014 1014 - return err 1015 1015 - } 1016 1016 - if _, err := cw.WriteString(string("repoName")); err != nil { 1017 1017 - return err 1018 1018 - } 1019 1019 - 1020 1020 - if len(t.RepoName) > 1000000 { 1021 1021 - return xerrors.Errorf("Value in field t.RepoName was too long") 1022 1022 - } 1023 1023 - 1024 1024 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoName))); err != nil { 1025 1025 - return err 1026 1026 - } 1027 1027 - if _, err := cw.WriteString(string(t.RepoName)); err != nil { 1028 1028 - return err 893 893 + if t.Count >= 0 { 894 894 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Count)); err != nil { 895 895 + return err 896 896 + } 897 897 + } else { 898 898 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Count-1)); err != nil { 899 899 + return err 900 900 + } 1029 901 } 1030 902 1031 1031 - // t.CommitterDid (string) (string) 1032 1032 - if len("committerDid") > 1000000 { 1033 1033 - return xerrors.Errorf("Value in field \"committerDid\" was too long") 903 903 + // t.Email (string) (string) 904 904 + if len("email") > 1000000 { 905 905 + return xerrors.Errorf("Value in field \"email\" was too long") 1034 906 } 1035 907 1036 1036 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("committerDid"))); err != nil { 908 908 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("email"))); err != nil { 1037 909 return err 1038 910 } 1039 1039 - if _, err := cw.WriteString(string("committerDid")); err != nil { 911 911 + if _, err := cw.WriteString(string("email")); err != nil { 1040 912 return err 1041 913 } 1042 914 1043 1043 - if len(t.CommitterDid) > 1000000 { 1044 1044 - return xerrors.Errorf("Value in field t.CommitterDid was too long") 915 915 + if len(t.Email) > 1000000 { 916 916 + return xerrors.Errorf("Value in field t.Email was too long") 1045 917 } 1046 918 1047 1047 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CommitterDid))); err != nil { 919 919 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Email))); err != nil { 1048 920 return err 1049 921 } 1050 1050 - if _, err := cw.WriteString(string(t.CommitterDid)); err != nil { 922 922 + if _, err := cw.WriteString(string(t.Email)); err != nil { 1051 923 return err 1052 924 } 1053 925 return nil 1054 926 } 1055 927 1056 1056 - func (t *GitRefUpdate) UnmarshalCBOR(r io.Reader) (err error) { 1057 1057 - *t = GitRefUpdate{} 928 928 + func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) UnmarshalCBOR(r io.Reader) (err error) { 929 929 + *t = GitRefUpdate_Meta_CommitCount_ByEmail_Elem{} 1058 930 1059 931 cr := cbg.NewCborReader(r) 1060 932 ··· 1073 945 } 1074 946 1075 947 if extra > cbg.MaxLength { 1076 1076 - return fmt.Errorf("GitRefUpdate: map struct too large (%d)", extra) 948 948 + return fmt.Errorf("GitRefUpdate_Meta_CommitCount_ByEmail_Elem: map struct too large (%d)", extra) 1077 949 } 1078 950 1079 951 n := extra 1080 952 1081 1081 - nameBuf := make([]byte, 12) 953 953 + nameBuf := make([]byte, 5) 1082 954 for i := uint64(0); i < n; i++ { 1083 955 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1084 956 if err != nil { ··· 1094 966 } 1095 967 1096 968 switch string(nameBuf[:nameLen]) { 1097 1097 - // t.Ref (string) (string) 1098 1098 - case "ref": 1099 1099 - 969 969 + // t.Count (int64) (int64) 970 970 + case "count": 1100 971 { 1101 1101 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1102 1102 - if err != nil { 1103 1103 - return err 1104 1104 - } 1105 1105 - 1106 1106 - t.Ref = string(sval) 1107 1107 - } 1108 1108 - // t.Meta (tangled.GitRefUpdate_Meta) (struct) 1109 1109 - case "meta": 1110 1110 - 1111 1111 - { 1112 1112 - 1113 1113 - b, err := cr.ReadByte() 972 972 + maj, extra, err := cr.ReadHeader() 1114 973 if err != nil { 1115 974 return err 1116 975 } 1117 1117 - if b != cbg.CborNull[0] { 1118 1118 - if err := cr.UnreadByte(); err != nil { 1119 1119 - return err 976 976 + var extraI int64 977 977 + switch maj { 978 978 + case cbg.MajUnsignedInt: 979 979 + extraI = int64(extra) 980 980 + if extraI < 0 { 981 981 + return fmt.Errorf("int64 positive overflow") 1120 982 } 1121 1121 - t.Meta = new(GitRefUpdate_Meta) 1122 1122 - if err := t.Meta.UnmarshalCBOR(cr); err != nil { 1123 1123 - return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err) 983 983 + case cbg.MajNegativeInt: 984 984 + extraI = int64(extra) 985 985 + if extraI < 0 { 986 986 + return fmt.Errorf("int64 negative overflow") 1124 987 } 1125 1125 - } 1126 1126 - 1127 1127 - } 1128 1128 - // t.LexiconTypeID (string) (string) 1129 1129 - case "$type": 1130 1130 - 1131 1131 - { 1132 1132 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1133 1133 - if err != nil { 1134 1134 - return err 1135 1135 - } 1136 1136 - 1137 1137 - t.LexiconTypeID = string(sval) 1138 1138 - } 1139 1139 - // t.NewSha (string) (string) 1140 1140 - case "newSha": 1141 1141 - 1142 1142 - { 1143 1143 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1144 1144 - if err != nil { 1145 1145 - return err 1146 1146 - } 1147 1147 - 1148 1148 - t.NewSha = string(sval) 1149 1149 - } 1150 1150 - // t.OldSha (string) (string) 1151 1151 - case "oldSha": 1152 1152 - 1153 1153 - { 1154 1154 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1155 1155 - if err != nil { 1156 1156 - return err 1157 1157 - } 1158 1158 - 1159 1159 - t.OldSha = string(sval) 1160 1160 - } 1161 1161 - // t.RepoDid (string) (string) 1162 1162 - case "repoDid": 1163 1163 - 1164 1164 - { 1165 1165 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1166 1166 - if err != nil { 1167 1167 - return err 988 988 + extraI = -1 - extraI 989 989 + default: 990 990 + return fmt.Errorf("wrong type for int64 field: %d", maj) 1168 991 } 1169 992 1170 1170 - t.RepoDid = string(sval) 993 993 + t.Count = int64(extraI) 1171 994 } 1172 1172 - // t.RepoName (string) (string) 1173 1173 - case "repoName": 995 995 + // t.Email (string) (string) 996 996 + case "email": 1174 997 1175 998 { 1176 999 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 1178 1001 return err 1179 1002 } 1180 1003 1181 1181 - t.RepoName = string(sval) 1182 1182 - } 1183 1183 - // t.CommitterDid (string) (string) 1184 1184 - case "committerDid": 1185 1185 - 1186 1186 - { 1187 1187 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1188 1188 - if err != nil { 1189 1189 - return err 1190 1190 - } 1191 1191 - 1192 1192 - t.CommitterDid = string(sval) 1004 1004 + t.Email = string(sval) 1193 1005 } 1194 1006 1195 1007 default: ··· 1202 1014 1203 1015 return nil 1204 1016 } 1205 1205 - func (t *GitRefUpdate_Meta) MarshalCBOR(w io.Writer) error { 1017 1017 + func (t *GitRefUpdate_Meta_CommitCount) MarshalCBOR(w io.Writer) error { 1206 1018 if t == nil { 1207 1019 _, err := w.Write(cbg.CborNull) 1208 1020 return err 1209 1021 } 1210 1022 1211 1023 cw := cbg.NewCborWriter(w) 1212 1212 - fieldCount := 3 1024 1024 + fieldCount := 1 1213 1025 1214 1214 - if t.LangBreakdown == nil { 1026 1026 + if t.ByEmail == nil { 1215 1027 fieldCount-- 1216 1028 } 1217 1029 ··· 1219 1031 return err 1220 1032 } 1221 1033 1222 1222 - // t.CommitCount (tangled.GitRefUpdate_Meta_CommitCount) (struct) 1223 1223 - if len("commitCount") > 1000000 { 1224 1224 - return xerrors.Errorf("Value in field \"commitCount\" was too long") 1225 1225 - } 1226 1226 - 1227 1227 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commitCount"))); err != nil { 1228 1228 - return err 1229 1229 - } 1230 1230 - if _, err := cw.WriteString(string("commitCount")); err != nil { 1231 1231 - return err 1232 1232 - } 1233 1233 - 1234 1234 - if err := t.CommitCount.MarshalCBOR(cw); err != nil { 1235 1235 - return err 1236 1236 - } 1237 1237 - 1238 1238 - // t.IsDefaultRef (bool) (bool) 1239 1239 - if len("isDefaultRef") > 1000000 { 1240 1240 - return xerrors.Errorf("Value in field \"isDefaultRef\" was too long") 1241 1241 - } 1242 1242 - 1243 1243 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("isDefaultRef"))); err != nil { 1244 1244 - return err 1245 1245 - } 1246 1246 - if _, err := cw.WriteString(string("isDefaultRef")); err != nil { 1247 1247 - return err 1248 1248 - } 1249 1249 - 1250 1250 - if err := cbg.WriteBool(w, t.IsDefaultRef); err != nil { 1251 1251 - return err 1252 1252 - } 1034 1034 + // t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice) 1035 1035 + if t.ByEmail != nil { 1253 1036 1254 1254 - // t.LangBreakdown (tangled.GitRefUpdate_Meta_LangBreakdown) (struct) 1255 1255 - if t.LangBreakdown != nil { 1256 1256 - 1257 1257 - if len("langBreakdown") > 1000000 { 1258 1258 - return xerrors.Errorf("Value in field \"langBreakdown\" was too long") 1037 1037 + if len("byEmail") > 1000000 { 1038 1038 + return xerrors.Errorf("Value in field \"byEmail\" was too long") 1259 1039 } 1260 1040 1261 1261 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("langBreakdown"))); err != nil { 1041 1041 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byEmail"))); err != nil { 1262 1042 return err 1263 1043 } 1264 1264 - if _, err := cw.WriteString(string("langBreakdown")); err != nil { 1044 1044 + if _, err := cw.WriteString(string("byEmail")); err != nil { 1265 1045 return err 1266 1046 } 1267 1047 1268 1268 - if err := t.LangBreakdown.MarshalCBOR(cw); err != nil { 1048 1048 + if len(t.ByEmail) > 8192 { 1049 1049 + return xerrors.Errorf("Slice value in field t.ByEmail was too long") 1050 1050 + } 1051 1051 + 1052 1052 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ByEmail))); err != nil { 1269 1053 return err 1270 1054 } 1055 1055 + for _, v := range t.ByEmail { 1056 1056 + if err := v.MarshalCBOR(cw); err != nil { 1057 1057 + return err 1058 1058 + } 1059 1059 + 1060 1060 + } 1271 1061 } 1272 1062 return nil 1273 1063 } 1274 1064 1275 1275 - func (t *GitRefUpdate_Meta) UnmarshalCBOR(r io.Reader) (err error) { 1276 1276 - *t = GitRefUpdate_Meta{} 1065 1065 + func (t *GitRefUpdate_Meta_CommitCount) UnmarshalCBOR(r io.Reader) (err error) { 1066 1066 + *t = GitRefUpdate_Meta_CommitCount{} 1277 1067 1278 1068 cr := cbg.NewCborReader(r) 1279 1069 ··· 1292 1082 } 1293 1083 1294 1084 if extra > cbg.MaxLength { 1295 1295 - return fmt.Errorf("GitRefUpdate_Meta: map struct too large (%d)", extra) 1085 1085 + return fmt.Errorf("GitRefUpdate_Meta_CommitCount: map struct too large (%d)", extra) 1296 1086 } 1297 1087 1298 1088 n := extra 1299 1089 1300 1300 - nameBuf := make([]byte, 13) 1090 1090 + nameBuf := make([]byte, 7) 1301 1091 for i := uint64(0); i < n; i++ { 1302 1092 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1303 1093 if err != nil { ··· 1313 1103 } 1314 1104 1315 1105 switch string(nameBuf[:nameLen]) { 1316 1316 - // t.CommitCount (tangled.GitRefUpdate_Meta_CommitCount) (struct) 1317 1317 - case "commitCount": 1318 1318 - 1319 1319 - { 1320 1320 - 1321 1321 - b, err := cr.ReadByte() 1322 1322 - if err != nil { 1323 1323 - return err 1324 1324 - } 1325 1325 - if b != cbg.CborNull[0] { 1326 1326 - if err := cr.UnreadByte(); err != nil { 1327 1327 - return err 1328 1328 - } 1329 1329 - t.CommitCount = new(GitRefUpdate_Meta_CommitCount) 1330 1330 - if err := t.CommitCount.UnmarshalCBOR(cr); err != nil { 1331 1331 - return xerrors.Errorf("unmarshaling t.CommitCount pointer: %w", err) 1332 1332 - } 1333 1333 - } 1334 1334 - 1335 1335 - } 1336 1336 - // t.IsDefaultRef (bool) (bool) 1337 1337 - case "isDefaultRef": 1106 1106 + // t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice) 1107 1107 + case "byEmail": 1338 1108 1339 1109 maj, extra, err = cr.ReadHeader() 1340 1110 if err != nil { 1341 1111 return err 1342 1112 } 1343 1343 - if maj != cbg.MajOther { 1344 1344 - return fmt.Errorf("booleans must be major type 7") 1113 1113 + 1114 1114 + if extra > 8192 { 1115 1115 + return fmt.Errorf("t.ByEmail: array too large (%d)", extra) 1345 1116 } 1346 1346 - switch extra { 1347 1347 - case 20: 1348 1348 - t.IsDefaultRef = false 1349 1349 - case 21: 1350 1350 - t.IsDefaultRef = true 1351 1351 - default: 1352 1352 - return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) 1117 1117 + 1118 1118 + if maj != cbg.MajArray { 1119 1119 + return fmt.Errorf("expected cbor array") 1353 1120 } 1354 1354 - // t.LangBreakdown (tangled.GitRefUpdate_Meta_LangBreakdown) (struct) 1355 1355 - case "langBreakdown": 1356 1121 1357 1357 - { 1122 1122 + if extra > 0 { 1123 1123 + t.ByEmail = make([]*GitRefUpdate_Meta_CommitCount_ByEmail_Elem, extra) 1124 1124 + } 1358 1125 1359 1359 - b, err := cr.ReadByte() 1360 1360 - if err != nil { 1361 1361 - return err 1362 1362 - } 1363 1363 - if b != cbg.CborNull[0] { 1364 1364 - if err := cr.UnreadByte(); err != nil { 1365 1365 - return err 1366 1366 - } 1367 1367 - t.LangBreakdown = new(GitRefUpdate_Meta_LangBreakdown) 1368 1368 - if err := t.LangBreakdown.UnmarshalCBOR(cr); err != nil { 1369 1369 - return xerrors.Errorf("unmarshaling t.LangBreakdown pointer: %w", err) 1126 1126 + for i := 0; i < int(extra); i++ { 1127 1127 + { 1128 1128 + var maj byte 1129 1129 + var extra uint64 1130 1130 + var err error 1131 1131 + _ = maj 1132 1132 + _ = extra 1133 1133 + _ = err 1134 1134 + 1135 1135 + { 1136 1136 + 1137 1137 + b, err := cr.ReadByte() 1138 1138 + if err != nil { 1139 1139 + return err 1140 1140 + } 1141 1141 + if b != cbg.CborNull[0] { 1142 1142 + if err := cr.UnreadByte(); err != nil { 1143 1143 + return err 1144 1144 + } 1145 1145 + t.ByEmail[i] = new(GitRefUpdate_Meta_CommitCount_ByEmail_Elem) 1146 1146 + if err := t.ByEmail[i].UnmarshalCBOR(cr); err != nil { 1147 1147 + return xerrors.Errorf("unmarshaling t.ByEmail[i] pointer: %w", err) 1148 1148 + } 1149 1149 + } 1150 1150 + 1370 1151 } 1371 1371 - } 1372 1152 1153 1153 + } 1373 1154 } 1374 1155 1375 1156 default: ··· 1382 1163 1383 1164 return nil 1384 1165 } 1385 1385 - func (t *GitRefUpdate_Meta_CommitCount) MarshalCBOR(w io.Writer) error { 1166 1166 + func (t *GitRefUpdate_Meta_LangBreakdown) MarshalCBOR(w io.Writer) error { 1386 1167 if t == nil { 1387 1168 _, err := w.Write(cbg.CborNull) 1388 1169 return err ··· 1391 1172 cw := cbg.NewCborWriter(w) 1392 1173 fieldCount := 1 1393 1174 1394 1394 - if t.ByEmail == nil { 1175 1175 + if t.Inputs == nil { 1395 1176 fieldCount-- 1396 1177 } 1397 1178 ··· 1399 1180 return err 1400 1181 } 1401 1182 1402 1402 - // t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice) 1403 1403 - if t.ByEmail != nil { 1183 1183 + // t.Inputs ([]*tangled.GitRefUpdate_Pair) (slice) 1184 1184 + if t.Inputs != nil { 1404 1185 1405 1405 - if len("byEmail") > 1000000 { 1406 1406 - return xerrors.Errorf("Value in field \"byEmail\" was too long") 1186 1186 + if len("inputs") > 1000000 { 1187 1187 + return xerrors.Errorf("Value in field \"inputs\" was too long") 1407 1188 } 1408 1189 1409 1409 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byEmail"))); err != nil { 1190 1190 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil { 1410 1191 return err 1411 1192 } 1412 1412 - if _, err := cw.WriteString(string("byEmail")); err != nil { 1193 1193 + if _, err := cw.WriteString(string("inputs")); err != nil { 1413 1194 return err 1414 1195 } 1415 1196 1416 1416 - if len(t.ByEmail) > 8192 { 1417 1417 - return xerrors.Errorf("Slice value in field t.ByEmail was too long") 1197 1197 + if len(t.Inputs) > 8192 { 1198 1198 + return xerrors.Errorf("Slice value in field t.Inputs was too long") 1418 1199 } 1419 1200 1420 1420 - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ByEmail))); err != nil { 1201 1201 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil { 1421 1202 return err 1422 1203 } 1423 1423 - for _, v := range t.ByEmail { 1204 1204 + for _, v := range t.Inputs { 1424 1205 if err := v.MarshalCBOR(cw); err != nil { 1425 1206 return err 1426 1207 } ··· 1430 1211 return nil 1431 1212 } 1432 1213 1433 1433 - func (t *GitRefUpdate_Meta_CommitCount) UnmarshalCBOR(r io.Reader) (err error) { 1434 1434 - *t = GitRefUpdate_Meta_CommitCount{} 1214 1214 + func (t *GitRefUpdate_Meta_LangBreakdown) UnmarshalCBOR(r io.Reader) (err error) { 1215 1215 + *t = GitRefUpdate_Meta_LangBreakdown{} 1435 1216 1436 1217 cr := cbg.NewCborReader(r) 1437 1218 ··· 1450 1231 } 1451 1232 1452 1233 if extra > cbg.MaxLength { 1453 1453 - return fmt.Errorf("GitRefUpdate_Meta_CommitCount: map struct too large (%d)", extra) 1234 1234 + return fmt.Errorf("GitRefUpdate_Meta_LangBreakdown: map struct too large (%d)", extra) 1454 1235 } 1455 1236 1456 1237 n := extra 1457 1238 1458 1458 - nameBuf := make([]byte, 7) 1239 1239 + nameBuf := make([]byte, 6) 1459 1240 for i := uint64(0); i < n; i++ { 1460 1241 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1461 1242 if err != nil { ··· 1471 1252 } 1472 1253 1473 1254 switch string(nameBuf[:nameLen]) { 1474 1474 - // t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice) 1475 1475 - case "byEmail": 1255 1255 + // t.Inputs ([]*tangled.GitRefUpdate_Pair) (slice) 1256 1256 + case "inputs": 1476 1257 1477 1258 maj, extra, err = cr.ReadHeader() 1478 1259 if err != nil { ··· 1480 1261 } 1481 1262 1482 1263 if extra > 8192 { 1483 1483 - return fmt.Errorf("t.ByEmail: array too large (%d)", extra) 1264 1264 + return fmt.Errorf("t.Inputs: array too large (%d)", extra) 1484 1265 } 1485 1266 1486 1267 if maj != cbg.MajArray { ··· 1488 1269 } 1489 1270 1490 1271 if extra > 0 { 1491 1491 - t.ByEmail = make([]*GitRefUpdate_Meta_CommitCount_ByEmail_Elem, extra) 1272 1272 + t.Inputs = make([]*GitRefUpdate_Pair, extra) 1492 1273 } 1493 1274 1494 1275 for i := 0; i < int(extra); i++ { ··· 1510 1291 if err := cr.UnreadByte(); err != nil { 1511 1292 return err 1512 1293 } 1513 1513 - t.ByEmail[i] = new(GitRefUpdate_Meta_CommitCount_ByEmail_Elem) 1514 1514 - if err := t.ByEmail[i].UnmarshalCBOR(cr); err != nil { 1515 1515 - return xerrors.Errorf("unmarshaling t.ByEmail[i] pointer: %w", err) 1294 1294 + t.Inputs[i] = new(GitRefUpdate_Pair) 1295 1295 + if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil { 1296 1296 + return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err) 1516 1297 } 1517 1298 } 1518 1299 ··· 1531 1312 1532 1313 return nil 1533 1314 } 1534 1534 - func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) MarshalCBOR(w io.Writer) error { 1315 1315 + func (t *GitRefUpdate_Meta) MarshalCBOR(w io.Writer) error { 1535 1316 if t == nil { 1536 1317 _, err := w.Write(cbg.CborNull) 1537 1318 return err 1538 1319 } 1539 1320 1540 1321 cw := cbg.NewCborWriter(w) 1322 1322 + fieldCount := 3 1541 1323 1542 1542 - if _, err := cw.Write([]byte{162}); err != nil { 1324 1324 + if t.LangBreakdown == nil { 1325 1325 + fieldCount-- 1326 1326 + } 1327 1327 + 1328 1328 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 1543 1329 return err 1544 1330 } 1545 1331 1546 1546 - // t.Count (int64) (int64) 1547 1547 - if len("count") > 1000000 { 1548 1548 - return xerrors.Errorf("Value in field \"count\" was too long") 1332 1332 + // t.CommitCount (tangled.GitRefUpdate_Meta_CommitCount) (struct) 1333 1333 + if len("commitCount") > 1000000 { 1334 1334 + return xerrors.Errorf("Value in field \"commitCount\" was too long") 1549 1335 } 1550 1336 1551 1551 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("count"))); err != nil { 1337 1337 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commitCount"))); err != nil { 1552 1338 return err 1553 1339 } 1554 1554 - if _, err := cw.WriteString(string("count")); err != nil { 1340 1340 + if _, err := cw.WriteString(string("commitCount")); err != nil { 1555 1341 return err 1556 1342 } 1557 1343 1558 1558 - if t.Count >= 0 { 1559 1559 - if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Count)); err != nil { 1560 1560 - return err 1561 1561 - } 1562 1562 - } else { 1563 1563 - if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Count-1)); err != nil { 1564 1564 - return err 1565 1565 - } 1344 1344 + if err := t.CommitCount.MarshalCBOR(cw); err != nil { 1345 1345 + return err 1566 1346 } 1567 1347 1568 1568 - // t.Email (string) (string) 1569 1569 - if len("email") > 1000000 { 1570 1570 - return xerrors.Errorf("Value in field \"email\" was too long") 1348 1348 + // t.IsDefaultRef (bool) (bool) 1349 1349 + if len("isDefaultRef") > 1000000 { 1350 1350 + return xerrors.Errorf("Value in field \"isDefaultRef\" was too long") 1571 1351 } 1572 1352 1573 1573 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("email"))); err != nil { 1353 1353 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("isDefaultRef"))); err != nil { 1574 1354 return err 1575 1355 } 1576 1576 - if _, err := cw.WriteString(string("email")); err != nil { 1356 1356 + if _, err := cw.WriteString(string("isDefaultRef")); err != nil { 1577 1357 return err 1578 1358 } 1579 1359 1580 1580 - if len(t.Email) > 1000000 { 1581 1581 - return xerrors.Errorf("Value in field t.Email was too long") 1360 1360 + if err := cbg.WriteBool(w, t.IsDefaultRef); err != nil { 1361 1361 + return err 1582 1362 } 1583 1363 1584 1584 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Email))); err != nil { 1585 1585 - return err 1586 1586 - } 1587 1587 - if _, err := cw.WriteString(string(t.Email)); err != nil { 1588 1588 - return err 1364 1364 + // t.LangBreakdown (tangled.GitRefUpdate_Meta_LangBreakdown) (struct) 1365 1365 + if t.LangBreakdown != nil { 1366 1366 + 1367 1367 + if len("langBreakdown") > 1000000 { 1368 1368 + return xerrors.Errorf("Value in field \"langBreakdown\" was too long") 1369 1369 + } 1370 1370 + 1371 1371 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("langBreakdown"))); err != nil { 1372 1372 + return err 1373 1373 + } 1374 1374 + if _, err := cw.WriteString(string("langBreakdown")); err != nil { 1375 1375 + return err 1376 1376 + } 1377 1377 + 1378 1378 + if err := t.LangBreakdown.MarshalCBOR(cw); err != nil { 1379 1379 + return err 1380 1380 + } 1589 1381 } 1590 1382 return nil 1591 1383 } 1592 1384 1593 1593 - func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) UnmarshalCBOR(r io.Reader) (err error) { 1594 1594 - *t = GitRefUpdate_Meta_CommitCount_ByEmail_Elem{} 1385 1385 + func (t *GitRefUpdate_Meta) UnmarshalCBOR(r io.Reader) (err error) { 1386 1386 + *t = GitRefUpdate_Meta{} 1595 1387 1596 1388 cr := cbg.NewCborReader(r) 1597 1389 ··· 1610 1402 } 1611 1403 1612 1404 if extra > cbg.MaxLength { 1613 1613 - return fmt.Errorf("GitRefUpdate_Meta_CommitCount_ByEmail_Elem: map struct too large (%d)", extra) 1405 1405 + return fmt.Errorf("GitRefUpdate_Meta: map struct too large (%d)", extra) 1614 1406 } 1615 1407 1616 1408 n := extra 1617 1409 1618 1618 - nameBuf := make([]byte, 5) 1410 1410 + nameBuf := make([]byte, 13) 1619 1411 for i := uint64(0); i < n; i++ { 1620 1412 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1621 1413 if err != nil { ··· 1631 1423 } 1632 1424 1633 1425 switch string(nameBuf[:nameLen]) { 1634 1634 - // t.Count (int64) (int64) 1635 1635 - case "count": 1426 1426 + // t.CommitCount (tangled.GitRefUpdate_Meta_CommitCount) (struct) 1427 1427 + case "commitCount": 1428 1428 + 1636 1429 { 1637 1637 - maj, extra, err := cr.ReadHeader() 1430 1430 + 1431 1431 + b, err := cr.ReadByte() 1638 1432 if err != nil { 1639 1433 return err 1640 1434 } 1641 1641 - var extraI int64 1642 1642 - switch maj { 1643 1643 - case cbg.MajUnsignedInt: 1644 1644 - extraI = int64(extra) 1645 1645 - if extraI < 0 { 1646 1646 - return fmt.Errorf("int64 positive overflow") 1435 1435 + if b != cbg.CborNull[0] { 1436 1436 + if err := cr.UnreadByte(); err != nil { 1437 1437 + return err 1647 1438 } 1648 1648 - case cbg.MajNegativeInt: 1649 1649 - extraI = int64(extra) 1650 1650 - if extraI < 0 { 1651 1651 - return fmt.Errorf("int64 negative overflow") 1439 1439 + t.CommitCount = new(GitRefUpdate_Meta_CommitCount) 1440 1440 + if err := t.CommitCount.UnmarshalCBOR(cr); err != nil { 1441 1441 + return xerrors.Errorf("unmarshaling t.CommitCount pointer: %w", err) 1652 1442 } 1653 1653 - extraI = -1 - extraI 1654 1654 - default: 1655 1655 - return fmt.Errorf("wrong type for int64 field: %d", maj) 1656 1443 } 1657 1444 1658 1658 - t.Count = int64(extraI) 1445 1445 + } 1446 1446 + // t.IsDefaultRef (bool) (bool) 1447 1447 + case "isDefaultRef": 1448 1448 + 1449 1449 + maj, extra, err = cr.ReadHeader() 1450 1450 + if err != nil { 1451 1451 + return err 1452 1452 + } 1453 1453 + if maj != cbg.MajOther { 1454 1454 + return fmt.Errorf("booleans must be major type 7") 1455 1455 + } 1456 1456 + switch extra { 1457 1457 + case 20: 1458 1458 + t.IsDefaultRef = false 1459 1459 + case 21: 1460 1460 + t.IsDefaultRef = true 1461 1461 + default: 1462 1462 + return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) 1659 1463 } 1660 1660 - // t.Email (string) (string) 1661 1661 - case "email": 1464 1464 + // t.LangBreakdown (tangled.GitRefUpdate_Meta_LangBreakdown) (struct) 1465 1465 + case "langBreakdown": 1662 1466 1663 1467 { 1664 1664 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1468 1468 + 1469 1469 + b, err := cr.ReadByte() 1665 1470 if err != nil { 1666 1471 return err 1667 1472 } 1473 1473 + if b != cbg.CborNull[0] { 1474 1474 + if err := cr.UnreadByte(); err != nil { 1475 1475 + return err 1476 1476 + } 1477 1477 + t.LangBreakdown = new(GitRefUpdate_Meta_LangBreakdown) 1478 1478 + if err := t.LangBreakdown.UnmarshalCBOR(cr); err != nil { 1479 1479 + return xerrors.Errorf("unmarshaling t.LangBreakdown pointer: %w", err) 1480 1480 + } 1481 1481 + } 1668 1482 1669 1669 - t.Email = string(sval) 1670 1483 } 1671 1484 1672 1485 default: ··· 1679 1492 1680 1493 return nil 1681 1494 } 1682 1682 - func (t *GitRefUpdate_Meta_LangBreakdown) MarshalCBOR(w io.Writer) error { 1495 1495 + func (t *GitRefUpdate_Pair) MarshalCBOR(w io.Writer) error { 1683 1496 if t == nil { 1684 1497 _, err := w.Write(cbg.CborNull) 1685 1498 return err 1686 1499 } 1687 1500 1688 1501 cw := cbg.NewCborWriter(w) 1689 1689 - fieldCount := 1 1502 1502 + 1503 1503 + if _, err := cw.Write([]byte{162}); err != nil { 1504 1504 + return err 1505 1505 + } 1690 1506 1691 1691 - if t.Inputs == nil { 1692 1692 - fieldCount-- 1507 1507 + // t.Lang (string) (string) 1508 1508 + if len("lang") > 1000000 { 1509 1509 + return xerrors.Errorf("Value in field \"lang\" was too long") 1693 1510 } 1694 1511 1695 1695 - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 1512 1512 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil { 1513 1513 + return err 1514 1514 + } 1515 1515 + if _, err := cw.WriteString(string("lang")); err != nil { 1696 1516 return err 1697 1517 } 1698 1518 1699 1699 - // t.Inputs ([]*tangled.GitRefUpdate_Pair) (slice) 1700 1700 - if t.Inputs != nil { 1519 1519 + if len(t.Lang) > 1000000 { 1520 1520 + return xerrors.Errorf("Value in field t.Lang was too long") 1521 1521 + } 1701 1522 1702 1702 - if len("inputs") > 1000000 { 1703 1703 - return xerrors.Errorf("Value in field \"inputs\" was too long") 1704 1704 - } 1523 1523 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil { 1524 1524 + return err 1525 1525 + } 1526 1526 + if _, err := cw.WriteString(string(t.Lang)); err != nil { 1527 1527 + return err 1528 1528 + } 1705 1529 1706 1706 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil { 1707 1707 - return err 1708 1708 - } 1709 1709 - if _, err := cw.WriteString(string("inputs")); err != nil { 1710 1710 - return err 1711 1711 - } 1530 1530 + // t.Size (int64) (int64) 1531 1531 + if len("size") > 1000000 { 1532 1532 + return xerrors.Errorf("Value in field \"size\" was too long") 1533 1533 + } 1712 1534 1713 1713 - if len(t.Inputs) > 8192 { 1714 1714 - return xerrors.Errorf("Slice value in field t.Inputs was too long") 1715 1715 - } 1535 1535 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil { 1536 1536 + return err 1537 1537 + } 1538 1538 + if _, err := cw.WriteString(string("size")); err != nil { 1539 1539 + return err 1540 1540 + } 1716 1541 1717 1717 - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil { 1542 1542 + if t.Size >= 0 { 1543 1543 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil { 1718 1544 return err 1719 1545 } 1720 1720 - for _, v := range t.Inputs { 1721 1721 - if err := v.MarshalCBOR(cw); err != nil { 1722 1722 - return err 1723 1723 - } 1724 1724 - 1546 1546 + } else { 1547 1547 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); err != nil { 1548 1548 + return err 1725 1549 } 1726 1550 } 1551 1551 + 1727 1552 return nil 1728 1553 } 1729 1554 1730 1730 - func (t *GitRefUpdate_Meta_LangBreakdown) UnmarshalCBOR(r io.Reader) (err error) { 1731 1731 - *t = GitRefUpdate_Meta_LangBreakdown{} 1555 1555 + func (t *GitRefUpdate_Pair) UnmarshalCBOR(r io.Reader) (err error) { 1556 1556 + *t = GitRefUpdate_Pair{} 1732 1557 1733 1558 cr := cbg.NewCborReader(r) 1734 1559 ··· 1747 1572 } 1748 1573 1749 1574 if extra > cbg.MaxLength { 1750 1750 - return fmt.Errorf("GitRefUpdate_Meta_LangBreakdown: map struct too large (%d)", extra) 1575 1575 + return fmt.Errorf("GitRefUpdate_Pair: map struct too large (%d)", extra) 1751 1576 } 1752 1577 1753 1578 n := extra 1754 1579 1755 1755 - nameBuf := make([]byte, 6) 1580 1580 + nameBuf := make([]byte, 4) 1756 1581 for i := uint64(0); i < n; i++ { 1757 1582 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1758 1583 if err != nil { ··· 1768 1593 } 1769 1594 1770 1595 switch string(nameBuf[:nameLen]) { 1771 1771 - // t.Inputs ([]*tangled.GitRefUpdate_Pair) (slice) 1772 1772 - case "inputs": 1773 1773 - 1774 1774 - maj, extra, err = cr.ReadHeader() 1775 1775 - if err != nil { 1776 1776 - return err 1777 1777 - } 1596 1596 + // t.Lang (string) (string) 1597 1597 + case "lang": 1778 1598 1779 1779 - if extra > 8192 { 1780 1780 - return fmt.Errorf("t.Inputs: array too large (%d)", extra) 1781 1781 - } 1599 1599 + { 1600 1600 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1601 1601 + if err != nil { 1602 1602 + return err 1603 1603 + } 1782 1604 1783 1783 - if maj != cbg.MajArray { 1784 1784 - return fmt.Errorf("expected cbor array") 1605 1605 + t.Lang = string(sval) 1785 1606 } 1786 1786 - 1787 1787 - if extra > 0 { 1788 1788 - t.Inputs = make([]*GitRefUpdate_Pair, extra) 1789 1789 - } 1790 1790 - 1791 1791 - for i := 0; i < int(extra); i++ { 1792 1792 - { 1793 1793 - var maj byte 1794 1794 - var extra uint64 1795 1795 - var err error 1796 1796 - _ = maj 1797 1797 - _ = extra 1798 1798 - _ = err 1799 1799 - 1800 1800 - { 1801 1801 - 1802 1802 - b, err := cr.ReadByte() 1803 1803 - if err != nil { 1804 1804 - return err 1805 1805 - } 1806 1806 - if b != cbg.CborNull[0] { 1807 1807 - if err := cr.UnreadByte(); err != nil { 1808 1808 - return err 1809 1809 - } 1810 1810 - t.Inputs[i] = new(GitRefUpdate_Pair) 1811 1811 - if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil { 1812 1812 - return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err) 1813 1813 - } 1814 1814 - } 1815 1815 - 1607 1607 + // t.Size (int64) (int64) 1608 1608 + case "size": 1609 1609 + { 1610 1610 + maj, extra, err := cr.ReadHeader() 1611 1611 + if err != nil { 1612 1612 + return err 1613 1613 + } 1614 1614 + var extraI int64 1615 1615 + switch maj { 1616 1616 + case cbg.MajUnsignedInt: 1617 1617 + extraI = int64(extra) 1618 1618 + if extraI < 0 { 1619 1619 + return fmt.Errorf("int64 positive overflow") 1816 1620 } 1817 1817 - 1621 1621 + case cbg.MajNegativeInt: 1622 1622 + extraI = int64(extra) 1623 1623 + if extraI < 0 { 1624 1624 + return fmt.Errorf("int64 negative overflow") 1625 1625 + } 1626 1626 + extraI = -1 - extraI 1627 1627 + default: 1628 1628 + return fmt.Errorf("wrong type for int64 field: %d", maj) 1818 1629 } 1630 1630 + 1631 1631 + t.Size = int64(extraI) 1819 1632 } 1820 1633 1821 1634 default: ··· 1828 1641 1829 1642 return nil 1830 1643 } 1831 1831 - func (t *GitRefUpdate_Pair) MarshalCBOR(w io.Writer) error { 1644 1644 + func (t *GitRefUpdate) MarshalCBOR(w io.Writer) error { 1832 1645 if t == nil { 1833 1646 _, err := w.Write(cbg.CborNull) 1834 1647 return err ··· 1836 1649 1837 1650 cw := cbg.NewCborWriter(w) 1838 1651 1839 1839 - if _, err := cw.Write([]byte{162}); err != nil { 1652 1652 + if _, err := cw.Write([]byte{168}); err != nil { 1840 1653 return err 1841 1654 } 1842 1655 1843 1843 - // t.Lang (string) (string) 1844 1844 - if len("lang") > 1000000 { 1845 1845 - return xerrors.Errorf("Value in field \"lang\" was too long") 1656 1656 + // t.Ref (string) (string) 1657 1657 + if len("ref") > 1000000 { 1658 1658 + return xerrors.Errorf("Value in field \"ref\" was too long") 1846 1659 } 1847 1660 1848 1848 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil { 1661 1661 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil { 1849 1662 return err 1850 1663 } 1851 1851 - if _, err := cw.WriteString(string("lang")); err != nil { 1664 1664 + if _, err := cw.WriteString(string("ref")); err != nil { 1852 1665 return err 1853 1666 } 1854 1667 1855 1855 - if len(t.Lang) > 1000000 { 1856 1856 - return xerrors.Errorf("Value in field t.Lang was too long") 1668 1668 + if len(t.Ref) > 1000000 { 1669 1669 + return xerrors.Errorf("Value in field t.Ref was too long") 1857 1670 } 1858 1671 1859 1859 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil { 1672 1672 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil { 1860 1673 return err 1861 1674 } 1862 1862 - if _, err := cw.WriteString(string(t.Lang)); err != nil { 1675 1675 + if _, err := cw.WriteString(string(t.Ref)); err != nil { 1863 1676 return err 1864 1677 } 1865 1678 1866 1866 - // t.Size (int64) (int64) 1867 1867 - if len("size") > 1000000 { 1868 1868 - return xerrors.Errorf("Value in field \"size\" was too long") 1679 1679 + // t.Meta (tangled.GitRefUpdate_Meta) (struct) 1680 1680 + if len("meta") > 1000000 { 1681 1681 + return xerrors.Errorf("Value in field \"meta\" was too long") 1869 1682 } 1870 1683 1871 1871 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil { 1684 1684 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil { 1685 1685 + return err 1686 1686 + } 1687 1687 + if _, err := cw.WriteString(string("meta")); err != nil { 1872 1688 return err 1873 1689 } 1874 1874 - if _, err := cw.WriteString(string("size")); err != nil { 1690 1690 + 1691 1691 + if err := t.Meta.MarshalCBOR(cw); err != nil { 1875 1692 return err 1876 1693 } 1877 1694 1878 1878 - if t.Size >= 0 { 1879 1879 - if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil { 1880 1880 - return err 1881 1881 - } 1882 1882 - } else { 1883 1883 - if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); err != nil { 1884 1884 - return err 1885 1885 - } 1695 1695 + // t.LexiconTypeID (string) (string) 1696 1696 + if len("$type") > 1000000 { 1697 1697 + return xerrors.Errorf("Value in field \"$type\" was too long") 1698 1698 + } 1699 1699 + 1700 1700 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 1701 1701 + return err 1702 1702 + } 1703 1703 + if _, err := cw.WriteString(string("$type")); err != nil { 1704 1704 + return err 1705 1705 + } 1706 1706 + 1707 1707 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.git.refUpdate"))); err != nil { 1708 1708 + return err 1709 1709 + } 1710 1710 + if _, err := cw.WriteString(string("sh.tangled.git.refUpdate")); err != nil { 1711 1711 + return err 1712 1712 + } 1713 1713 + 1714 1714 + // t.NewSha (string) (string) 1715 1715 + if len("newSha") > 1000000 { 1716 1716 + return xerrors.Errorf("Value in field \"newSha\" was too long") 1717 1717 + } 1718 1718 + 1719 1719 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil { 1720 1720 + return err 1721 1721 + } 1722 1722 + if _, err := cw.WriteString(string("newSha")); err != nil { 1723 1723 + return err 1724 1724 + } 1725 1725 + 1726 1726 + if len(t.NewSha) > 1000000 { 1727 1727 + return xerrors.Errorf("Value in field t.NewSha was too long") 1728 1728 + } 1729 1729 + 1730 1730 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil { 1731 1731 + return err 1732 1732 + } 1733 1733 + if _, err := cw.WriteString(string(t.NewSha)); err != nil { 1734 1734 + return err 1735 1735 + } 1736 1736 + 1737 1737 + // t.OldSha (string) (string) 1738 1738 + if len("oldSha") > 1000000 { 1739 1739 + return xerrors.Errorf("Value in field \"oldSha\" was too long") 1740 1740 + } 1741 1741 + 1742 1742 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil { 1743 1743 + return err 1744 1744 + } 1745 1745 + if _, err := cw.WriteString(string("oldSha")); err != nil { 1746 1746 + return err 1747 1747 + } 1748 1748 + 1749 1749 + if len(t.OldSha) > 1000000 { 1750 1750 + return xerrors.Errorf("Value in field t.OldSha was too long") 1751 1751 + } 1752 1752 + 1753 1753 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil { 1754 1754 + return err 1755 1755 + } 1756 1756 + if _, err := cw.WriteString(string(t.OldSha)); err != nil { 1757 1757 + return err 1758 1758 + } 1759 1759 + 1760 1760 + // t.RepoDid (string) (string) 1761 1761 + if len("repoDid") > 1000000 { 1762 1762 + return xerrors.Errorf("Value in field \"repoDid\" was too long") 1763 1763 + } 1764 1764 + 1765 1765 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil { 1766 1766 + return err 1767 1767 + } 1768 1768 + if _, err := cw.WriteString(string("repoDid")); err != nil { 1769 1769 + return err 1770 1770 + } 1771 1771 + 1772 1772 + if len(t.RepoDid) > 1000000 { 1773 1773 + return xerrors.Errorf("Value in field t.RepoDid was too long") 1774 1774 + } 1775 1775 + 1776 1776 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoDid))); err != nil { 1777 1777 + return err 1778 1778 + } 1779 1779 + if _, err := cw.WriteString(string(t.RepoDid)); err != nil { 1780 1780 + return err 1781 1781 + } 1782 1782 + 1783 1783 + // t.RepoName (string) (string) 1784 1784 + if len("repoName") > 1000000 { 1785 1785 + return xerrors.Errorf("Value in field \"repoName\" was too long") 1786 1786 + } 1787 1787 + 1788 1788 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoName"))); err != nil { 1789 1789 + return err 1790 1790 + } 1791 1791 + if _, err := cw.WriteString(string("repoName")); err != nil { 1792 1792 + return err 1793 1793 + } 1794 1794 + 1795 1795 + if len(t.RepoName) > 1000000 { 1796 1796 + return xerrors.Errorf("Value in field t.RepoName was too long") 1797 1797 + } 1798 1798 + 1799 1799 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoName))); err != nil { 1800 1800 + return err 1801 1801 + } 1802 1802 + if _, err := cw.WriteString(string(t.RepoName)); err != nil { 1803 1803 + return err 1804 1804 + } 1805 1805 + 1806 1806 + // t.CommitterDid (string) (string) 1807 1807 + if len("committerDid") > 1000000 { 1808 1808 + return xerrors.Errorf("Value in field \"committerDid\" was too long") 1809 1809 + } 1810 1810 + 1811 1811 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("committerDid"))); err != nil { 1812 1812 + return err 1813 1813 + } 1814 1814 + if _, err := cw.WriteString(string("committerDid")); err != nil { 1815 1815 + return err 1816 1816 + } 1817 1817 + 1818 1818 + if len(t.CommitterDid) > 1000000 { 1819 1819 + return xerrors.Errorf("Value in field t.CommitterDid was too long") 1886 1820 } 1887 1821 1822 1822 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CommitterDid))); err != nil { 1823 1823 + return err 1824 1824 + } 1825 1825 + if _, err := cw.WriteString(string(t.CommitterDid)); err != nil { 1826 1826 + return err 1827 1827 + } 1888 1828 return nil 1889 1829 } 1890 1830 1891 1891 - func (t *GitRefUpdate_Pair) UnmarshalCBOR(r io.Reader) (err error) { 1892 1892 - *t = GitRefUpdate_Pair{} 1831 1831 + func (t *GitRefUpdate) UnmarshalCBOR(r io.Reader) (err error) { 1832 1832 + *t = GitRefUpdate{} 1893 1833 1894 1834 cr := cbg.NewCborReader(r) 1895 1835 ··· 1908 1848 } 1909 1849 1910 1850 if extra > cbg.MaxLength { 1911 1911 - return fmt.Errorf("GitRefUpdate_Pair: map struct too large (%d)", extra) 1851 1851 + return fmt.Errorf("GitRefUpdate: map struct too large (%d)", extra) 1912 1852 } 1913 1853 1914 1854 n := extra 1915 1855 1916 1916 - nameBuf := make([]byte, 4) 1856 1856 + nameBuf := make([]byte, 12) 1917 1857 for i := uint64(0); i < n; i++ { 1918 1858 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1919 1859 if err != nil { ··· 1929 1869 } 1930 1870 1931 1871 switch string(nameBuf[:nameLen]) { 1932 1932 - // t.Lang (string) (string) 1933 1933 - case "lang": 1872 1872 + // t.Ref (string) (string) 1873 1873 + case "ref": 1934 1874 1935 1875 { 1936 1876 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 1938 1878 return err 1939 1879 } 1940 1880 1941 1941 - t.Lang = string(sval) 1881 1881 + t.Ref = string(sval) 1942 1882 } 1943 1943 - // t.Size (int64) (int64) 1944 1944 - case "size": 1883 1883 + // t.Meta (tangled.GitRefUpdate_Meta) (struct) 1884 1884 + case "meta": 1885 1885 + 1945 1886 { 1946 1946 - maj, extra, err := cr.ReadHeader() 1887 1887 + 1888 1888 + b, err := cr.ReadByte() 1947 1889 if err != nil { 1948 1890 return err 1949 1891 } 1950 1950 - var extraI int64 1951 1951 - switch maj { 1952 1952 - case cbg.MajUnsignedInt: 1953 1953 - extraI = int64(extra) 1954 1954 - if extraI < 0 { 1955 1955 - return fmt.Errorf("int64 positive overflow") 1892 1892 + if b != cbg.CborNull[0] { 1893 1893 + if err := cr.UnreadByte(); err != nil { 1894 1894 + return err 1956 1895 } 1957 1957 - case cbg.MajNegativeInt: 1958 1958 - extraI = int64(extra) 1959 1959 - if extraI < 0 { 1960 1960 - return fmt.Errorf("int64 negative overflow") 1896 1896 + t.Meta = new(GitRefUpdate_Meta) 1897 1897 + if err := t.Meta.UnmarshalCBOR(cr); err != nil { 1898 1898 + return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err) 1961 1899 } 1962 1962 - extraI = -1 - extraI 1963 1963 - default: 1964 1964 - return fmt.Errorf("wrong type for int64 field: %d", maj) 1965 1900 } 1966 1901 1967 1967 - t.Size = int64(extraI) 1902 1902 + } 1903 1903 + // t.LexiconTypeID (string) (string) 1904 1904 + case "$type": 1905 1905 + 1906 1906 + { 1907 1907 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1908 1908 + if err != nil { 1909 1909 + return err 1910 1910 + } 1911 1911 + 1912 1912 + t.LexiconTypeID = string(sval) 1913 1913 + } 1914 1914 + // t.NewSha (string) (string) 1915 1915 + case "newSha": 1916 1916 + 1917 1917 + { 1918 1918 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1919 1919 + if err != nil { 1920 1920 + return err 1921 1921 + } 1922 1922 + 1923 1923 + t.NewSha = string(sval) 1924 1924 + } 1925 1925 + // t.OldSha (string) (string) 1926 1926 + case "oldSha": 1927 1927 + 1928 1928 + { 1929 1929 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1930 1930 + if err != nil { 1931 1931 + return err 1932 1932 + } 1933 1933 + 1934 1934 + t.OldSha = string(sval) 1935 1935 + } 1936 1936 + // t.RepoDid (string) (string) 1937 1937 + case "repoDid": 1938 1938 + 1939 1939 + { 1940 1940 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1941 1941 + if err != nil { 1942 1942 + return err 1943 1943 + } 1944 1944 + 1945 1945 + t.RepoDid = string(sval) 1946 1946 + } 1947 1947 + // t.RepoName (string) (string) 1948 1948 + case "repoName": 1949 1949 + 1950 1950 + { 1951 1951 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1952 1952 + if err != nil { 1953 1953 + return err 1954 1954 + } 1955 1955 + 1956 1956 + t.RepoName = string(sval) 1957 1957 + } 1958 1958 + // t.CommitterDid (string) (string) 1959 1959 + case "committerDid": 1960 1960 + 1961 1961 + { 1962 1962 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1963 1963 + if err != nil { 1964 1964 + return err 1965 1965 + } 1966 1966 + 1967 1967 + t.CommitterDid = string(sval) 1968 1968 } 1969 1969 1970 1970 default: ··· 2339 2339 2340 2340 return nil 2341 2341 } 2342 2342 - func (t *Pipeline) MarshalCBOR(w io.Writer) error { 2342 2342 + func (t *Knot) MarshalCBOR(w io.Writer) error { 2343 2343 if t == nil { 2344 2344 _, err := w.Write(cbg.CborNull) 2345 2345 return err ··· 2347 2347 2348 2348 cw := cbg.NewCborWriter(w) 2349 2349 2350 2350 - if _, err := cw.Write([]byte{163}); err != nil { 2350 2350 + if _, err := cw.Write([]byte{162}); err != nil { 2351 2351 return err 2352 2352 } 2353 2353 ··· 2363 2363 return err 2364 2364 } 2365 2365 2366 2366 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil { 2366 2366 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot"))); err != nil { 2367 2367 return err 2368 2368 } 2369 2369 - if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil { 2369 2369 + if _, err := cw.WriteString(string("sh.tangled.knot")); err != nil { 2370 2370 return err 2371 2371 } 2372 2372 2373 2373 - // t.Workflows ([]*tangled.Pipeline_Workflow) (slice) 2374 2374 - if len("workflows") > 1000000 { 2375 2375 - return xerrors.Errorf("Value in field \"workflows\" was too long") 2373 2373 + // t.CreatedAt (string) (string) 2374 2374 + if len("createdAt") > 1000000 { 2375 2375 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 2376 2376 } 2377 2377 2378 2378 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil { 2378 2378 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 2379 2379 return err 2380 2380 } 2381 2381 - if _, err := cw.WriteString(string("workflows")); err != nil { 2381 2381 + if _, err := cw.WriteString(string("createdAt")); err != nil { 2382 2382 return err 2383 2383 } 2384 2384 2385 2385 - if len(t.Workflows) > 8192 { 2386 2386 - return xerrors.Errorf("Slice value in field t.Workflows was too long") 2385 2385 + if len(t.CreatedAt) > 1000000 { 2386 2386 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 2387 2387 } 2388 2388 2389 2389 - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil { 2389 2389 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 2390 2390 + return err 2391 2391 + } 2392 2392 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 2393 2393 + return err 2394 2394 + } 2395 2395 + return nil 2396 2396 + } 2397 2397 + 2398 2398 + func (t *Knot) UnmarshalCBOR(r io.Reader) (err error) { 2399 2399 + *t = Knot{} 2400 2400 + 2401 2401 + cr := cbg.NewCborReader(r) 2402 2402 + 2403 2403 + maj, extra, err := cr.ReadHeader() 2404 2404 + if err != nil { 2390 2405 return err 2391 2406 } 2392 2392 - for _, v := range t.Workflows { 2393 2393 - if err := v.MarshalCBOR(cw); err != nil { 2407 2407 + defer func() { 2408 2408 + if err == io.EOF { 2409 2409 + err = io.ErrUnexpectedEOF 2410 2410 + } 2411 2411 + }() 2412 2412 + 2413 2413 + if maj != cbg.MajMap { 2414 2414 + return fmt.Errorf("cbor input should be of type map") 2415 2415 + } 2416 2416 + 2417 2417 + if extra > cbg.MaxLength { 2418 2418 + return fmt.Errorf("Knot: map struct too large (%d)", extra) 2419 2419 + } 2420 2420 + 2421 2421 + n := extra 2422 2422 + 2423 2423 + nameBuf := make([]byte, 9) 2424 2424 + for i := uint64(0); i < n; i++ { 2425 2425 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2426 2426 + if err != nil { 2394 2427 return err 2395 2428 } 2396 2429 2430 2430 + if !ok { 2431 2431 + // Field doesn't exist on this type, so ignore it 2432 2432 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2433 2433 + return err 2434 2434 + } 2435 2435 + continue 2436 2436 + } 2437 2437 + 2438 2438 + switch string(nameBuf[:nameLen]) { 2439 2439 + // t.LexiconTypeID (string) (string) 2440 2440 + case "$type": 2441 2441 + 2442 2442 + { 2443 2443 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2444 2444 + if err != nil { 2445 2445 + return err 2446 2446 + } 2447 2447 + 2448 2448 + t.LexiconTypeID = string(sval) 2449 2449 + } 2450 2450 + // t.CreatedAt (string) (string) 2451 2451 + case "createdAt": 2452 2452 + 2453 2453 + { 2454 2454 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2455 2455 + if err != nil { 2456 2456 + return err 2457 2457 + } 2458 2458 + 2459 2459 + t.CreatedAt = string(sval) 2460 2460 + } 2461 2461 + 2462 2462 + default: 2463 2463 + // Field doesn't exist on this type, so ignore it 2464 2464 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2465 2465 + return err 2466 2466 + } 2467 2467 + } 2397 2468 } 2398 2469 2399 2399 - // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct) 2400 2400 - if len("triggerMetadata") > 1000000 { 2401 2401 - return xerrors.Errorf("Value in field \"triggerMetadata\" was too long") 2470 2470 + return nil 2471 2471 + } 2472 2472 + func (t *PipelineStatus) MarshalCBOR(w io.Writer) error { 2473 2473 + if t == nil { 2474 2474 + _, err := w.Write(cbg.CborNull) 2475 2475 + return err 2402 2476 } 2403 2477 2404 2404 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil { 2478 2478 + cw := cbg.NewCborWriter(w) 2479 2479 + fieldCount := 7 2480 2480 + 2481 2481 + if t.Error == nil { 2482 2482 + fieldCount-- 2483 2483 + } 2484 2484 + 2485 2485 + if t.ExitCode == nil { 2486 2486 + fieldCount-- 2487 2487 + } 2488 2488 + 2489 2489 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 2405 2490 return err 2406 2491 } 2407 2407 - if _, err := cw.WriteString(string("triggerMetadata")); err != nil { 2492 2492 + 2493 2493 + // t.LexiconTypeID (string) (string) 2494 2494 + if len("$type") > 1000000 { 2495 2495 + return xerrors.Errorf("Value in field \"$type\" was too long") 2496 2496 + } 2497 2497 + 2498 2498 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 2499 2499 + return err 2500 2500 + } 2501 2501 + if _, err := cw.WriteString(string("$type")); err != nil { 2408 2502 return err 2409 2503 } 2410 2504 2411 2411 - if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil { 2505 2505 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline.status"))); err != nil { 2506 2506 + return err 2507 2507 + } 2508 2508 + if _, err := cw.WriteString(string("sh.tangled.pipeline.status")); err != nil { 2509 2509 + return err 2510 2510 + } 2511 2511 + 2512 2512 + // t.Error (string) (string) 2513 2513 + if t.Error != nil { 2514 2514 + 2515 2515 + if len("error") > 1000000 { 2516 2516 + return xerrors.Errorf("Value in field \"error\" was too long") 2517 2517 + } 2518 2518 + 2519 2519 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("error"))); err != nil { 2520 2520 + return err 2521 2521 + } 2522 2522 + if _, err := cw.WriteString(string("error")); err != nil { 2523 2523 + return err 2524 2524 + } 2525 2525 + 2526 2526 + if t.Error == nil { 2527 2527 + if _, err := cw.Write(cbg.CborNull); err != nil { 2528 2528 + return err 2529 2529 + } 2530 2530 + } else { 2531 2531 + if len(*t.Error) > 1000000 { 2532 2532 + return xerrors.Errorf("Value in field t.Error was too long") 2533 2533 + } 2534 2534 + 2535 2535 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Error))); err != nil { 2536 2536 + return err 2537 2537 + } 2538 2538 + if _, err := cw.WriteString(string(*t.Error)); err != nil { 2539 2539 + return err 2540 2540 + } 2541 2541 + } 2542 2542 + } 2543 2543 + 2544 2544 + // t.Status (string) (string) 2545 2545 + if len("status") > 1000000 { 2546 2546 + return xerrors.Errorf("Value in field \"status\" was too long") 2547 2547 + } 2548 2548 + 2549 2549 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil { 2550 2550 + return err 2551 2551 + } 2552 2552 + if _, err := cw.WriteString(string("status")); err != nil { 2553 2553 + return err 2554 2554 + } 2555 2555 + 2556 2556 + if len(t.Status) > 1000000 { 2557 2557 + return xerrors.Errorf("Value in field t.Status was too long") 2558 2558 + } 2559 2559 + 2560 2560 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil { 2561 2561 + return err 2562 2562 + } 2563 2563 + if _, err := cw.WriteString(string(t.Status)); err != nil { 2564 2564 + return err 2565 2565 + } 2566 2566 + 2567 2567 + // t.ExitCode (int64) (int64) 2568 2568 + if t.ExitCode != nil { 2569 2569 + 2570 2570 + if len("exitCode") > 1000000 { 2571 2571 + return xerrors.Errorf("Value in field \"exitCode\" was too long") 2572 2572 + } 2573 2573 + 2574 2574 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("exitCode"))); err != nil { 2575 2575 + return err 2576 2576 + } 2577 2577 + if _, err := cw.WriteString(string("exitCode")); err != nil { 2578 2578 + return err 2579 2579 + } 2580 2580 + 2581 2581 + if t.ExitCode == nil { 2582 2582 + if _, err := cw.Write(cbg.CborNull); err != nil { 2583 2583 + return err 2584 2584 + } 2585 2585 + } else { 2586 2586 + if *t.ExitCode >= 0 { 2587 2587 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.ExitCode)); err != nil { 2588 2588 + return err 2589 2589 + } 2590 2590 + } else { 2591 2591 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.ExitCode-1)); err != nil { 2592 2592 + return err 2593 2593 + } 2594 2594 + } 2595 2595 + } 2596 2596 + 2597 2597 + } 2598 2598 + 2599 2599 + // t.Pipeline (string) (string) 2600 2600 + if len("pipeline") > 1000000 { 2601 2601 + return xerrors.Errorf("Value in field \"pipeline\" was too long") 2602 2602 + } 2603 2603 + 2604 2604 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pipeline"))); err != nil { 2605 2605 + return err 2606 2606 + } 2607 2607 + if _, err := cw.WriteString(string("pipeline")); err != nil { 2608 2608 + return err 2609 2609 + } 2610 2610 + 2611 2611 + if len(t.Pipeline) > 1000000 { 2612 2612 + return xerrors.Errorf("Value in field t.Pipeline was too long") 2613 2613 + } 2614 2614 + 2615 2615 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pipeline))); err != nil { 2616 2616 + return err 2617 2617 + } 2618 2618 + if _, err := cw.WriteString(string(t.Pipeline)); err != nil { 2619 2619 + return err 2620 2620 + } 2621 2621 + 2622 2622 + // t.Workflow (string) (string) 2623 2623 + if len("workflow") > 1000000 { 2624 2624 + return xerrors.Errorf("Value in field \"workflow\" was too long") 2625 2625 + } 2626 2626 + 2627 2627 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil { 2628 2628 + return err 2629 2629 + } 2630 2630 + if _, err := cw.WriteString(string("workflow")); err != nil { 2631 2631 + return err 2632 2632 + } 2633 2633 + 2634 2634 + if len(t.Workflow) > 1000000 { 2635 2635 + return xerrors.Errorf("Value in field t.Workflow was too long") 2636 2636 + } 2637 2637 + 2638 2638 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil { 2639 2639 + return err 2640 2640 + } 2641 2641 + if _, err := cw.WriteString(string(t.Workflow)); err != nil { 2642 2642 + return err 2643 2643 + } 2644 2644 + 2645 2645 + // t.CreatedAt (string) (string) 2646 2646 + if len("createdAt") > 1000000 { 2647 2647 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 2648 2648 + } 2649 2649 + 2650 2650 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 2651 2651 + return err 2652 2652 + } 2653 2653 + if _, err := cw.WriteString(string("createdAt")); err != nil { 2654 2654 + return err 2655 2655 + } 2656 2656 + 2657 2657 + if len(t.CreatedAt) > 1000000 { 2658 2658 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 2659 2659 + } 2660 2660 + 2661 2661 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 2662 2662 + return err 2663 2663 + } 2664 2664 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 2412 2665 return err 2413 2666 } 2414 2667 return nil 2415 2668 } 2416 2669 2417 2417 - func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) { 2418 2418 - *t = Pipeline{} 2670 2670 + func (t *PipelineStatus) UnmarshalCBOR(r io.Reader) (err error) { 2671 2671 + *t = PipelineStatus{} 2419 2672 2420 2673 cr := cbg.NewCborReader(r) 2421 2674 ··· 2434 2687 } 2435 2688 2436 2689 if extra > cbg.MaxLength { 2437 2437 - return fmt.Errorf("Pipeline: map struct too large (%d)", extra) 2690 2690 + return fmt.Errorf("PipelineStatus: map struct too large (%d)", extra) 2438 2691 } 2439 2692 2440 2693 n := extra 2441 2694 2442 2442 - nameBuf := make([]byte, 15) 2695 2695 + nameBuf := make([]byte, 9) 2443 2696 for i := uint64(0); i < n; i++ { 2444 2697 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2445 2698 if err != nil { ··· 2466 2719 2467 2720 t.LexiconTypeID = string(sval) 2468 2721 } 2469 2469 - // t.Workflows ([]*tangled.Pipeline_Workflow) (slice) 2470 2470 - case "workflows": 2722 2722 + // t.Error (string) (string) 2723 2723 + case "error": 2471 2724 2472 2472 - maj, extra, err = cr.ReadHeader() 2473 2473 - if err != nil { 2474 2474 - return err 2475 2475 - } 2725 2725 + { 2726 2726 + b, err := cr.ReadByte() 2727 2727 + if err != nil { 2728 2728 + return err 2729 2729 + } 2730 2730 + if b != cbg.CborNull[0] { 2731 2731 + if err := cr.UnreadByte(); err != nil { 2732 2732 + return err 2733 2733 + } 2476 2734 2477 2477 - if extra > 8192 { 2478 2478 - return fmt.Errorf("t.Workflows: array too large (%d)", extra) 2735 2735 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2736 2736 + if err != nil { 2737 2737 + return err 2738 2738 + } 2739 2739 + 2740 2740 + t.Error = (*string)(&sval) 2741 2741 + } 2479 2742 } 2743 2743 + // t.Status (string) (string) 2744 2744 + case "status": 2480 2745 2481 2481 - if maj != cbg.MajArray { 2482 2482 - return fmt.Errorf("expected cbor array") 2483 2483 - } 2746 2746 + { 2747 2747 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2748 2748 + if err != nil { 2749 2749 + return err 2750 2750 + } 2484 2751 2485 2485 - if extra > 0 { 2486 2486 - t.Workflows = make([]*Pipeline_Workflow, extra) 2752 2752 + t.Status = string(sval) 2487 2753 } 2754 2754 + // t.ExitCode (int64) (int64) 2755 2755 + case "exitCode": 2756 2756 + { 2488 2757 2489 2489 - for i := 0; i < int(extra); i++ { 2490 2490 - { 2491 2491 - var maj byte 2492 2492 - var extra uint64 2493 2493 - var err error 2494 2494 - _ = maj 2495 2495 - _ = extra 2496 2496 - _ = err 2497 2497 - 2498 2498 - { 2499 2499 - 2500 2500 - b, err := cr.ReadByte() 2501 2501 - if err != nil { 2502 2502 - return err 2758 2758 + b, err := cr.ReadByte() 2759 2759 + if err != nil { 2760 2760 + return err 2761 2761 + } 2762 2762 + if b != cbg.CborNull[0] { 2763 2763 + if err := cr.UnreadByte(); err != nil { 2764 2764 + return err 2765 2765 + } 2766 2766 + maj, extra, err := cr.ReadHeader() 2767 2767 + if err != nil { 2768 2768 + return err 2769 2769 + } 2770 2770 + var extraI int64 2771 2771 + switch maj { 2772 2772 + case cbg.MajUnsignedInt: 2773 2773 + extraI = int64(extra) 2774 2774 + if extraI < 0 { 2775 2775 + return fmt.Errorf("int64 positive overflow") 2503 2776 } 2504 2504 - if b != cbg.CborNull[0] { 2505 2505 - if err := cr.UnreadByte(); err != nil { 2506 2506 - return err 2507 2507 - } 2508 2508 - t.Workflows[i] = new(Pipeline_Workflow) 2509 2509 - if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil { 2510 2510 - return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err) 2511 2511 - } 2777 2777 + case cbg.MajNegativeInt: 2778 2778 + extraI = int64(extra) 2779 2779 + if extraI < 0 { 2780 2780 + return fmt.Errorf("int64 negative overflow") 2512 2781 } 2513 2513 - 2782 2782 + extraI = -1 - extraI 2783 2783 + default: 2784 2784 + return fmt.Errorf("wrong type for int64 field: %d", maj) 2514 2785 } 2515 2786 2787 2787 + t.ExitCode = (*int64)(&extraI) 2516 2788 } 2517 2789 } 2518 2518 - // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct) 2519 2519 - case "triggerMetadata": 2790 2790 + // t.Pipeline (string) (string) 2791 2791 + case "pipeline": 2520 2792 2521 2793 { 2794 2794 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2795 2795 + if err != nil { 2796 2796 + return err 2797 2797 + } 2522 2798 2523 2523 - b, err := cr.ReadByte() 2799 2799 + t.Pipeline = string(sval) 2800 2800 + } 2801 2801 + // t.Workflow (string) (string) 2802 2802 + case "workflow": 2803 2803 + 2804 2804 + { 2805 2805 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2524 2806 if err != nil { 2525 2807 return err 2526 2808 } 2527 2527 - if b != cbg.CborNull[0] { 2528 2528 - if err := cr.UnreadByte(); err != nil { 2529 2529 - return err 2530 2530 - } 2531 2531 - t.TriggerMetadata = new(Pipeline_TriggerMetadata) 2532 2532 - if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil { 2533 2533 - return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err) 2534 2534 - } 2809 2809 + 2810 2810 + t.Workflow = string(sval) 2811 2811 + } 2812 2812 + // t.CreatedAt (string) (string) 2813 2813 + case "createdAt": 2814 2814 + 2815 2815 + { 2816 2816 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2817 2817 + if err != nil { 2818 2818 + return err 2535 2819 } 2536 2820 2821 2821 + t.CreatedAt = string(sval) 2537 2822 } 2538 2823 2539 2824 default: ··· 3554 3839 3555 3840 return nil 3556 3841 } 3557 3557 - func (t *PipelineStatus) MarshalCBOR(w io.Writer) error { 3558 3558 - if t == nil { 3559 3559 - _, err := w.Write(cbg.CborNull) 3560 3560 - return err 3561 3561 - } 3562 3562 - 3563 3563 - cw := cbg.NewCborWriter(w) 3564 3564 - fieldCount := 7 3565 3565 - 3566 3566 - if t.Error == nil { 3567 3567 - fieldCount-- 3568 3568 - } 3569 3569 - 3570 3570 - if t.ExitCode == nil { 3571 3571 - fieldCount-- 3572 3572 - } 3573 3573 - 3574 3574 - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 3575 3575 - return err 3576 3576 - } 3577 3577 - 3578 3578 - // t.LexiconTypeID (string) (string) 3579 3579 - if len("$type") > 1000000 { 3580 3580 - return xerrors.Errorf("Value in field \"$type\" was too long") 3581 3581 - } 3582 3582 - 3583 3583 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 3584 3584 - return err 3585 3585 - } 3586 3586 - if _, err := cw.WriteString(string("$type")); err != nil { 3587 3587 - return err 3588 3588 - } 3589 3589 - 3590 3590 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline.status"))); err != nil { 3591 3591 - return err 3592 3592 - } 3593 3593 - if _, err := cw.WriteString(string("sh.tangled.pipeline.status")); err != nil { 3594 3594 - return err 3595 3595 - } 3596 3596 - 3597 3597 - // t.Error (string) (string) 3598 3598 - if t.Error != nil { 3599 3599 - 3600 3600 - if len("error") > 1000000 { 3601 3601 - return xerrors.Errorf("Value in field \"error\" was too long") 3602 3602 - } 3603 3603 - 3604 3604 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("error"))); err != nil { 3605 3605 - return err 3606 3606 - } 3607 3607 - if _, err := cw.WriteString(string("error")); err != nil { 3608 3608 - return err 3609 3609 - } 3610 3610 - 3611 3611 - if t.Error == nil { 3612 3612 - if _, err := cw.Write(cbg.CborNull); err != nil { 3613 3613 - return err 3614 3614 - } 3615 3615 - } else { 3616 3616 - if len(*t.Error) > 1000000 { 3617 3617 - return xerrors.Errorf("Value in field t.Error was too long") 3618 3618 - } 3619 3619 - 3620 3620 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Error))); err != nil { 3621 3621 - return err 3622 3622 - } 3623 3623 - if _, err := cw.WriteString(string(*t.Error)); err != nil { 3624 3624 - return err 3625 3625 - } 3626 3626 - } 3627 3627 - } 3628 3628 - 3629 3629 - // t.Status (string) (string) 3630 3630 - if len("status") > 1000000 { 3631 3631 - return xerrors.Errorf("Value in field \"status\" was too long") 3632 3632 - } 3633 3633 - 3634 3634 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil { 3635 3635 - return err 3636 3636 - } 3637 3637 - if _, err := cw.WriteString(string("status")); err != nil { 3638 3638 - return err 3639 3639 - } 3640 3640 - 3641 3641 - if len(t.Status) > 1000000 { 3642 3642 - return xerrors.Errorf("Value in field t.Status was too long") 3643 3643 - } 3644 3644 - 3645 3645 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil { 3646 3646 - return err 3647 3647 - } 3648 3648 - if _, err := cw.WriteString(string(t.Status)); err != nil { 3649 3649 - return err 3650 3650 - } 3651 3651 - 3652 3652 - // t.ExitCode (int64) (int64) 3653 3653 - if t.ExitCode != nil { 3654 3654 - 3655 3655 - if len("exitCode") > 1000000 { 3656 3656 - return xerrors.Errorf("Value in field \"exitCode\" was too long") 3657 3657 - } 3658 3658 - 3659 3659 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("exitCode"))); err != nil { 3660 3660 - return err 3661 3661 - } 3662 3662 - if _, err := cw.WriteString(string("exitCode")); err != nil { 3663 3663 - return err 3664 3664 - } 3665 3665 - 3666 3666 - if t.ExitCode == nil { 3667 3667 - if _, err := cw.Write(cbg.CborNull); err != nil { 3668 3668 - return err 3669 3669 - } 3670 3670 - } else { 3671 3671 - if *t.ExitCode >= 0 { 3672 3672 - if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.ExitCode)); err != nil { 3673 3673 - return err 3674 3674 - } 3675 3675 - } else { 3676 3676 - if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.ExitCode-1)); err != nil { 3677 3677 - return err 3678 3678 - } 3679 3679 - } 3680 3680 - } 3681 3681 - 3682 3682 - } 3683 3683 - 3684 3684 - // t.Pipeline (string) (string) 3685 3685 - if len("pipeline") > 1000000 { 3686 3686 - return xerrors.Errorf("Value in field \"pipeline\" was too long") 3687 3687 - } 3688 3688 - 3689 3689 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pipeline"))); err != nil { 3690 3690 - return err 3691 3691 - } 3692 3692 - if _, err := cw.WriteString(string("pipeline")); err != nil { 3693 3693 - return err 3694 3694 - } 3695 3695 - 3696 3696 - if len(t.Pipeline) > 1000000 { 3697 3697 - return xerrors.Errorf("Value in field t.Pipeline was too long") 3698 3698 - } 3699 3699 - 3700 3700 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pipeline))); err != nil { 3701 3701 - return err 3702 3702 - } 3703 3703 - if _, err := cw.WriteString(string(t.Pipeline)); err != nil { 3704 3704 - return err 3705 3705 - } 3706 3706 - 3707 3707 - // t.Workflow (string) (string) 3708 3708 - if len("workflow") > 1000000 { 3709 3709 - return xerrors.Errorf("Value in field \"workflow\" was too long") 3710 3710 - } 3711 3711 - 3712 3712 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil { 3713 3713 - return err 3714 3714 - } 3715 3715 - if _, err := cw.WriteString(string("workflow")); err != nil { 3716 3716 - return err 3717 3717 - } 3718 3718 - 3719 3719 - if len(t.Workflow) > 1000000 { 3720 3720 - return xerrors.Errorf("Value in field t.Workflow was too long") 3721 3721 - } 3722 3722 - 3723 3723 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil { 3724 3724 - return err 3725 3725 - } 3726 3726 - if _, err := cw.WriteString(string(t.Workflow)); err != nil { 3727 3727 - return err 3728 3728 - } 3729 3729 - 3730 3730 - // t.CreatedAt (string) (string) 3731 3731 - if len("createdAt") > 1000000 { 3732 3732 - return xerrors.Errorf("Value in field \"createdAt\" was too long") 3733 3733 - } 3734 3734 - 3735 3735 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 3736 3736 - return err 3737 3737 - } 3738 3738 - if _, err := cw.WriteString(string("createdAt")); err != nil { 3739 3739 - return err 3740 3740 - } 3741 3741 - 3742 3742 - if len(t.CreatedAt) > 1000000 { 3743 3743 - return xerrors.Errorf("Value in field t.CreatedAt was too long") 3744 3744 - } 3745 3745 - 3746 3746 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 3747 3747 - return err 3748 3748 - } 3749 3749 - if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 3750 3750 - return err 3751 3751 - } 3752 3752 - return nil 3753 3753 - } 3754 3754 - 3755 3755 - func (t *PipelineStatus) UnmarshalCBOR(r io.Reader) (err error) { 3756 3756 - *t = PipelineStatus{} 3757 3757 - 3758 3758 - cr := cbg.NewCborReader(r) 3759 3759 - 3760 3760 - maj, extra, err := cr.ReadHeader() 3761 3761 - if err != nil { 3762 3762 - return err 3763 3763 - } 3764 3764 - defer func() { 3765 3765 - if err == io.EOF { 3766 3766 - err = io.ErrUnexpectedEOF 3767 3767 - } 3768 3768 - }() 3769 3769 - 3770 3770 - if maj != cbg.MajMap { 3771 3771 - return fmt.Errorf("cbor input should be of type map") 3772 3772 - } 3773 3773 - 3774 3774 - if extra > cbg.MaxLength { 3775 3775 - return fmt.Errorf("PipelineStatus: map struct too large (%d)", extra) 3776 3776 - } 3777 3777 - 3778 3778 - n := extra 3779 3779 - 3780 3780 - nameBuf := make([]byte, 9) 3781 3781 - for i := uint64(0); i < n; i++ { 3782 3782 - nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3783 3783 - if err != nil { 3784 3784 - return err 3785 3785 - } 3786 3786 - 3787 3787 - if !ok { 3788 3788 - // Field doesn't exist on this type, so ignore it 3789 3789 - if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3790 3790 - return err 3791 3791 - } 3792 3792 - continue 3793 3793 - } 3794 3794 - 3795 3795 - switch string(nameBuf[:nameLen]) { 3796 3796 - // t.LexiconTypeID (string) (string) 3797 3797 - case "$type": 3798 3798 - 3799 3799 - { 3800 3800 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3801 3801 - if err != nil { 3802 3802 - return err 3803 3803 - } 3804 3804 - 3805 3805 - t.LexiconTypeID = string(sval) 3806 3806 - } 3807 3807 - // t.Error (string) (string) 3808 3808 - case "error": 3809 3809 - 3810 3810 - { 3811 3811 - b, err := cr.ReadByte() 3812 3812 - if err != nil { 3813 3813 - return err 3814 3814 - } 3815 3815 - if b != cbg.CborNull[0] { 3816 3816 - if err := cr.UnreadByte(); err != nil { 3817 3817 - return err 3818 3818 - } 3819 3819 - 3820 3820 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3821 3821 - if err != nil { 3822 3822 - return err 3823 3823 - } 3824 3824 - 3825 3825 - t.Error = (*string)(&sval) 3826 3826 - } 3827 3827 - } 3828 3828 - // t.Status (string) (string) 3829 3829 - case "status": 3830 3830 - 3831 3831 - { 3832 3832 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3833 3833 - if err != nil { 3834 3834 - return err 3835 3835 - } 3836 3836 - 3837 3837 - t.Status = string(sval) 3838 3838 - } 3839 3839 - // t.ExitCode (int64) (int64) 3840 3840 - case "exitCode": 3841 3841 - { 3842 3842 - 3843 3843 - b, err := cr.ReadByte() 3844 3844 - if err != nil { 3845 3845 - return err 3846 3846 - } 3847 3847 - if b != cbg.CborNull[0] { 3848 3848 - if err := cr.UnreadByte(); err != nil { 3849 3849 - return err 3850 3850 - } 3851 3851 - maj, extra, err := cr.ReadHeader() 3852 3852 - if err != nil { 3853 3853 - return err 3854 3854 - } 3855 3855 - var extraI int64 3856 3856 - switch maj { 3857 3857 - case cbg.MajUnsignedInt: 3858 3858 - extraI = int64(extra) 3859 3859 - if extraI < 0 { 3860 3860 - return fmt.Errorf("int64 positive overflow") 3861 3861 - } 3862 3862 - case cbg.MajNegativeInt: 3863 3863 - extraI = int64(extra) 3864 3864 - if extraI < 0 { 3865 3865 - return fmt.Errorf("int64 negative overflow") 3866 3866 - } 3867 3867 - extraI = -1 - extraI 3868 3868 - default: 3869 3869 - return fmt.Errorf("wrong type for int64 field: %d", maj) 3870 3870 - } 3871 3871 - 3872 3872 - t.ExitCode = (*int64)(&extraI) 3873 3873 - } 3874 3874 - } 3875 3875 - // t.Pipeline (string) (string) 3876 3876 - case "pipeline": 3877 3877 - 3878 3878 - { 3879 3879 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3880 3880 - if err != nil { 3881 3881 - return err 3882 3882 - } 3883 3883 - 3884 3884 - t.Pipeline = string(sval) 3885 3885 - } 3886 3886 - // t.Workflow (string) (string) 3887 3887 - case "workflow": 3888 3888 - 3889 3889 - { 3890 3890 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3891 3891 - if err != nil { 3892 3892 - return err 3893 3893 - } 3894 3894 - 3895 3895 - t.Workflow = string(sval) 3896 3896 - } 3897 3897 - // t.CreatedAt (string) (string) 3898 3898 - case "createdAt": 3899 3899 - 3900 3900 - { 3901 3901 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3902 3902 - if err != nil { 3903 3903 - return err 3904 3904 - } 3905 3905 - 3906 3906 - t.CreatedAt = string(sval) 3907 3907 - } 3908 3908 - 3909 3909 - default: 3910 3910 - // Field doesn't exist on this type, so ignore it 3911 3911 - if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3912 3912 - return err 3913 3913 - } 3914 3914 - } 3915 3915 - } 3916 3916 - 3917 3917 - return nil 3918 3918 - } 3919 3842 func (t *Pipeline_Step) MarshalCBOR(w io.Writer) error { 3920 3843 if t == nil { 3921 3844 _, err := w.Write(cbg.CborNull) ··· 4962 4885 4963 4886 return nil 4964 4887 } 4965 4965 - func (t *PublicKey) MarshalCBOR(w io.Writer) error { 4888 4888 + func (t *Pipeline) MarshalCBOR(w io.Writer) error { 4966 4889 if t == nil { 4967 4890 _, err := w.Write(cbg.CborNull) 4968 4891 return err ··· 4970 4893 4971 4894 cw := cbg.NewCborWriter(w) 4972 4895 4973 4973 - if _, err := cw.Write([]byte{164}); err != nil { 4974 4974 - return err 4975 4975 - } 4976 4976 - 4977 4977 - // t.Key (string) (string) 4978 4978 - if len("key") > 1000000 { 4979 4979 - return xerrors.Errorf("Value in field \"key\" was too long") 4980 4980 - } 4981 4981 - 4982 4982 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil { 4983 4983 - return err 4984 4984 - } 4985 4985 - if _, err := cw.WriteString(string("key")); err != nil { 4896 4896 + if _, err := cw.Write([]byte{163}); err != nil { 4986 4897 return err 4987 4898 } 4988 4899 4989 4989 - if len(t.Key) > 1000000 { 4990 4990 - return xerrors.Errorf("Value in field t.Key was too long") 4900 4900 + // t.LexiconTypeID (string) (string) 4901 4901 + if len("$type") > 1000000 { 4902 4902 + return xerrors.Errorf("Value in field \"$type\" was too long") 4991 4903 } 4992 4904 4993 4993 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil { 4905 4905 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 4994 4906 return err 4995 4907 } 4996 4996 - if _, err := cw.WriteString(string(t.Key)); err != nil { 4908 4908 + if _, err := cw.WriteString(string("$type")); err != nil { 4997 4909 return err 4998 4910 } 4999 4911 5000 5000 - // t.Name (string) (string) 5001 5001 - if len("name") > 1000000 { 5002 5002 - return xerrors.Errorf("Value in field \"name\" was too long") 5003 5003 - } 5004 5004 - 5005 5005 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 4912 4912 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil { 5006 4913 return err 5007 4914 } 5008 5008 - if _, err := cw.WriteString(string("name")); err != nil { 4915 4915 + if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil { 5009 4916 return err 5010 4917 } 5011 4918 5012 5012 - if len(t.Name) > 1000000 { 5013 5013 - return xerrors.Errorf("Value in field t.Name was too long") 4919 4919 + // t.Workflows ([]*tangled.Pipeline_Workflow) (slice) 4920 4920 + if len("workflows") > 1000000 { 4921 4921 + return xerrors.Errorf("Value in field \"workflows\" was too long") 5014 4922 } 5015 4923 5016 5016 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 4924 4924 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil { 5017 4925 return err 5018 4926 } 5019 5019 - if _, err := cw.WriteString(string(t.Name)); err != nil { 4927 4927 + if _, err := cw.WriteString(string("workflows")); err != nil { 5020 4928 return err 5021 4929 } 5022 4930 5023 5023 - // t.LexiconTypeID (string) (string) 5024 5024 - if len("$type") > 1000000 { 5025 5025 - return xerrors.Errorf("Value in field \"$type\" was too long") 4931 4931 + if len(t.Workflows) > 8192 { 4932 4932 + return xerrors.Errorf("Slice value in field t.Workflows was too long") 5026 4933 } 5027 4934 5028 5028 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 5029 5029 - return err 5030 5030 - } 5031 5031 - if _, err := cw.WriteString(string("$type")); err != nil { 4935 4935 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil { 5032 4936 return err 5033 4937 } 4938 4938 + for _, v := range t.Workflows { 4939 4939 + if err := v.MarshalCBOR(cw); err != nil { 4940 4940 + return err 4941 4941 + } 5034 4942 5035 5035 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil { 5036 5036 - return err 5037 5037 - } 5038 5038 - if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil { 5039 5039 - return err 5040 4943 } 5041 4944 5042 5042 - // t.CreatedAt (string) (string) 5043 5043 - if len("createdAt") > 1000000 { 5044 5044 - return xerrors.Errorf("Value in field \"createdAt\" was too long") 4945 4945 + // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct) 4946 4946 + if len("triggerMetadata") > 1000000 { 4947 4947 + return xerrors.Errorf("Value in field \"triggerMetadata\" was too long") 5045 4948 } 5046 4949 5047 5047 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 4950 4950 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil { 5048 4951 return err 5049 4952 } 5050 5050 - if _, err := cw.WriteString(string("createdAt")); err != nil { 4953 4953 + if _, err := cw.WriteString(string("triggerMetadata")); err != nil { 5051 4954 return err 5052 4955 } 5053 4956 5054 5054 - if len(t.CreatedAt) > 1000000 { 5055 5055 - return xerrors.Errorf("Value in field t.CreatedAt was too long") 5056 5056 - } 5057 5057 - 5058 5058 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 5059 5059 - return err 5060 5060 - } 5061 5061 - if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 4957 4957 + if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil { 5062 4958 return err 5063 4959 } 5064 4960 return nil 5065 4961 } 5066 4962 5067 5067 - func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) { 5068 5068 - *t = PublicKey{} 4963 4963 + func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) { 4964 4964 + *t = Pipeline{} 5069 4965 5070 4966 cr := cbg.NewCborReader(r) 5071 4967 ··· 5084 4980 } 5085 4981 5086 4982 if extra > cbg.MaxLength { 5087 5087 - return fmt.Errorf("PublicKey: map struct too large (%d)", extra) 4983 4983 + return fmt.Errorf("Pipeline: map struct too large (%d)", extra) 5088 4984 } 5089 4985 5090 4986 n := extra 5091 4987 5092 5092 - nameBuf := make([]byte, 9) 4988 4988 + nameBuf := make([]byte, 15) 5093 4989 for i := uint64(0); i < n; i++ { 5094 4990 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 5095 4991 if err != nil { ··· 5105 5001 } 5106 5002 5107 5003 switch string(nameBuf[:nameLen]) { 5108 5108 - // t.Key (string) (string) 5109 5109 - case "key": 5004 5004 + // t.LexiconTypeID (string) (string) 5005 5005 + case "$type": 5110 5006 5111 5007 { 5112 5008 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 5114 5010 return err 5115 5011 } 5116 5012 5117 5117 - t.Key = string(sval) 5013 5013 + t.LexiconTypeID = string(sval) 5118 5014 } 5119 5119 - // t.Name (string) (string) 5120 5120 - case "name": 5015 5015 + // t.Workflows ([]*tangled.Pipeline_Workflow) (slice) 5016 5016 + case "workflows": 5121 5017 5122 5122 - { 5123 5123 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5124 5124 - if err != nil { 5125 5125 - return err 5126 5126 - } 5018 5018 + maj, extra, err = cr.ReadHeader() 5019 5019 + if err != nil { 5020 5020 + return err 5021 5021 + } 5127 5022 5128 5128 - t.Name = string(sval) 5023 5023 + if extra > 8192 { 5024 5024 + return fmt.Errorf("t.Workflows: array too large (%d)", extra) 5129 5025 } 5130 5130 - // t.LexiconTypeID (string) (string) 5131 5131 - case "$type": 5132 5026 5133 5133 - { 5134 5134 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5135 5135 - if err != nil { 5136 5136 - return err 5137 5137 - } 5027 5027 + if maj != cbg.MajArray { 5028 5028 + return fmt.Errorf("expected cbor array") 5029 5029 + } 5138 5030 5139 5139 - t.LexiconTypeID = string(sval) 5031 5031 + if extra > 0 { 5032 5032 + t.Workflows = make([]*Pipeline_Workflow, extra) 5140 5033 } 5141 5141 - // t.CreatedAt (string) (string) 5142 5142 - case "createdAt": 5034 5034 + 5035 5035 + for i := 0; i < int(extra); i++ { 5036 5036 + { 5037 5037 + var maj byte 5038 5038 + var extra uint64 5039 5039 + var err error 5040 5040 + _ = maj 5041 5041 + _ = extra 5042 5042 + _ = err 5043 5043 + 5044 5044 + { 5045 5045 + 5046 5046 + b, err := cr.ReadByte() 5047 5047 + if err != nil { 5048 5048 + return err 5049 5049 + } 5050 5050 + if b != cbg.CborNull[0] { 5051 5051 + if err := cr.UnreadByte(); err != nil { 5052 5052 + return err 5053 5053 + } 5054 5054 + t.Workflows[i] = new(Pipeline_Workflow) 5055 5055 + if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil { 5056 5056 + return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err) 5057 5057 + } 5058 5058 + } 5059 5059 + 5060 5060 + } 5061 5061 + 5062 5062 + } 5063 5063 + } 5064 5064 + // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct) 5065 5065 + case "triggerMetadata": 5143 5066 5144 5067 { 5145 5145 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5068 5068 + 5069 5069 + b, err := cr.ReadByte() 5146 5070 if err != nil { 5147 5071 return err 5148 5072 } 5073 5073 + if b != cbg.CborNull[0] { 5074 5074 + if err := cr.UnreadByte(); err != nil { 5075 5075 + return err 5076 5076 + } 5077 5077 + t.TriggerMetadata = new(Pipeline_TriggerMetadata) 5078 5078 + if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil { 5079 5079 + return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err) 5080 5080 + } 5081 5081 + } 5149 5082 5150 5150 - t.CreatedAt = string(sval) 5151 5083 } 5152 5084 5153 5085 default: ··· 5160 5092 5161 5093 return nil 5162 5094 } 5163 5163 - func (t *Repo) MarshalCBOR(w io.Writer) error { 5095 5095 + func (t *PublicKey) MarshalCBOR(w io.Writer) error { 5164 5096 if t == nil { 5165 5097 _, err := w.Write(cbg.CborNull) 5166 5098 return err 5167 5099 } 5168 5100 5169 5101 cw := cbg.NewCborWriter(w) 5170 5170 - fieldCount := 8 5171 5102 5172 5172 - if t.Description == nil { 5173 5173 - fieldCount-- 5174 5174 - } 5175 5175 - 5176 5176 - if t.Source == nil { 5177 5177 - fieldCount-- 5178 5178 - } 5179 5179 - 5180 5180 - if t.Spindle == nil { 5181 5181 - fieldCount-- 5182 5182 - } 5183 5183 - 5184 5184 - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 5103 5103 + if _, err := cw.Write([]byte{164}); err != nil { 5185 5104 return err 5186 5105 } 5187 5106 5188 5188 - // t.Knot (string) (string) 5189 5189 - if len("knot") > 1000000 { 5190 5190 - return xerrors.Errorf("Value in field \"knot\" was too long") 5107 5107 + // t.Key (string) (string) 5108 5108 + if len("key") > 1000000 { 5109 5109 + return xerrors.Errorf("Value in field \"key\" was too long") 5191 5110 } 5192 5111 5193 5193 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil { 5112 5112 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil { 5194 5113 return err 5195 5114 } 5196 5196 - if _, err := cw.WriteString(string("knot")); err != nil { 5115 5115 + if _, err := cw.WriteString(string("key")); err != nil { 5197 5116 return err 5198 5117 } 5199 5118 5200 5200 - if len(t.Knot) > 1000000 { 5201 5201 - return xerrors.Errorf("Value in field t.Knot was too long") 5119 5119 + if len(t.Key) > 1000000 { 5120 5120 + return xerrors.Errorf("Value in field t.Key was too long") 5202 5121 } 5203 5122 5204 5204 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil { 5123 5123 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil { 5205 5124 return err 5206 5125 } 5207 5207 - if _, err := cw.WriteString(string(t.Knot)); err != nil { 5126 5126 + if _, err := cw.WriteString(string(t.Key)); err != nil { 5208 5127 return err 5209 5128 } 5210 5129 ··· 5243 5162 return err 5244 5163 } 5245 5164 5246 5246 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil { 5247 5247 - return err 5248 5248 - } 5249 5249 - if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil { 5250 5250 - return err 5251 5251 - } 5252 5252 - 5253 5253 - // t.Owner (string) (string) 5254 5254 - if len("owner") > 1000000 { 5255 5255 - return xerrors.Errorf("Value in field \"owner\" was too long") 5256 5256 - } 5257 5257 - 5258 5258 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil { 5259 5259 - return err 5260 5260 - } 5261 5261 - if _, err := cw.WriteString(string("owner")); err != nil { 5262 5262 - return err 5263 5263 - } 5264 5264 - 5265 5265 - if len(t.Owner) > 1000000 { 5266 5266 - return xerrors.Errorf("Value in field t.Owner was too long") 5267 5267 - } 5268 5268 - 5269 5269 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil { 5165 5165 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil { 5270 5166 return err 5271 5167 } 5272 5272 - if _, err := cw.WriteString(string(t.Owner)); err != nil { 5168 5168 + if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil { 5273 5169 return err 5274 5170 } 5275 5171 5276 5276 - // t.Source (string) (string) 5277 5277 - if t.Source != nil { 5278 5278 - 5279 5279 - if len("source") > 1000000 { 5280 5280 - return xerrors.Errorf("Value in field \"source\" was too long") 5281 5281 - } 5282 5282 - 5283 5283 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil { 5284 5284 - return err 5285 5285 - } 5286 5286 - if _, err := cw.WriteString(string("source")); err != nil { 5287 5287 - return err 5288 5288 - } 5289 5289 - 5290 5290 - if t.Source == nil { 5291 5291 - if _, err := cw.Write(cbg.CborNull); err != nil { 5292 5292 - return err 5293 5293 - } 5294 5294 - } else { 5295 5295 - if len(*t.Source) > 1000000 { 5296 5296 - return xerrors.Errorf("Value in field t.Source was too long") 5297 5297 - } 5298 5298 - 5299 5299 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil { 5300 5300 - return err 5301 5301 - } 5302 5302 - if _, err := cw.WriteString(string(*t.Source)); err != nil { 5303 5303 - return err 5304 5304 - } 5305 5305 - } 5306 5306 - } 5307 5307 - 5308 5308 - // t.Spindle (string) (string) 5309 5309 - if t.Spindle != nil { 5310 5310 - 5311 5311 - if len("spindle") > 1000000 { 5312 5312 - return xerrors.Errorf("Value in field \"spindle\" was too long") 5313 5313 - } 5314 5314 - 5315 5315 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("spindle"))); err != nil { 5316 5316 - return err 5317 5317 - } 5318 5318 - if _, err := cw.WriteString(string("spindle")); err != nil { 5319 5319 - return err 5320 5320 - } 5321 5321 - 5322 5322 - if t.Spindle == nil { 5323 5323 - if _, err := cw.Write(cbg.CborNull); err != nil { 5324 5324 - return err 5325 5325 - } 5326 5326 - } else { 5327 5327 - if len(*t.Spindle) > 1000000 { 5328 5328 - return xerrors.Errorf("Value in field t.Spindle was too long") 5329 5329 - } 5330 5330 - 5331 5331 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Spindle))); err != nil { 5332 5332 - return err 5333 5333 - } 5334 5334 - if _, err := cw.WriteString(string(*t.Spindle)); err != nil { 5335 5335 - return err 5336 5336 - } 5337 5337 - } 5338 5338 - } 5339 5339 - 5340 5172 // t.CreatedAt (string) (string) 5341 5173 if len("createdAt") > 1000000 { 5342 5174 return xerrors.Errorf("Value in field \"createdAt\" was too long") ··· 5359 5191 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 5360 5192 return err 5361 5193 } 5362 5362 - 5363 5363 - // t.Description (string) (string) 5364 5364 - if t.Description != nil { 5365 5365 - 5366 5366 - if len("description") > 1000000 { 5367 5367 - return xerrors.Errorf("Value in field \"description\" was too long") 5368 5368 - } 5369 5369 - 5370 5370 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil { 5371 5371 - return err 5372 5372 - } 5373 5373 - if _, err := cw.WriteString(string("description")); err != nil { 5374 5374 - return err 5375 5375 - } 5376 5376 - 5377 5377 - if t.Description == nil { 5378 5378 - if _, err := cw.Write(cbg.CborNull); err != nil { 5379 5379 - return err 5380 5380 - } 5381 5381 - } else { 5382 5382 - if len(*t.Description) > 1000000 { 5383 5383 - return xerrors.Errorf("Value in field t.Description was too long") 5384 5384 - } 5385 5385 - 5386 5386 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil { 5387 5387 - return err 5388 5388 - } 5389 5389 - if _, err := cw.WriteString(string(*t.Description)); err != nil { 5390 5390 - return err 5391 5391 - } 5392 5392 - } 5393 5393 - } 5394 5194 return nil 5395 5195 } 5396 5196 5397 5397 - func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) { 5398 5398 - *t = Repo{} 5197 5197 + func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) { 5198 5198 + *t = PublicKey{} 5399 5199 5400 5200 cr := cbg.NewCborReader(r) 5401 5201 ··· 5414 5214 } 5415 5215 5416 5216 if extra > cbg.MaxLength { 5417 5417 - return fmt.Errorf("Repo: map struct too large (%d)", extra) 5217 5217 + return fmt.Errorf("PublicKey: map struct too large (%d)", extra) 5418 5218 } 5419 5219 5420 5220 n := extra 5421 5221 5422 5422 - nameBuf := make([]byte, 11) 5222 5222 + nameBuf := make([]byte, 9) 5423 5223 for i := uint64(0); i < n; i++ { 5424 5224 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 5425 5225 if err != nil { ··· 5435 5235 } 5436 5236 5437 5237 switch string(nameBuf[:nameLen]) { 5438 5438 - // t.Knot (string) (string) 5439 5439 - case "knot": 5238 5238 + // t.Key (string) (string) 5239 5239 + case "key": 5440 5240 5441 5241 { 5442 5242 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 5444 5244 return err 5445 5245 } 5446 5246 5447 5447 - t.Knot = string(sval) 5247 5247 + t.Key = string(sval) 5448 5248 } 5449 5249 // t.Name (string) (string) 5450 5250 case "name": ··· 5468 5268 5469 5269 t.LexiconTypeID = string(sval) 5470 5270 } 5471 5471 - // t.Owner (string) (string) 5472 5472 - case "owner": 5473 5473 - 5474 5474 - { 5475 5475 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5476 5476 - if err != nil { 5477 5477 - return err 5478 5478 - } 5479 5479 - 5480 5480 - t.Owner = string(sval) 5481 5481 - } 5482 5482 - // t.Source (string) (string) 5483 5483 - case "source": 5484 5484 - 5485 5485 - { 5486 5486 - b, err := cr.ReadByte() 5487 5487 - if err != nil { 5488 5488 - return err 5489 5489 - } 5490 5490 - if b != cbg.CborNull[0] { 5491 5491 - if err := cr.UnreadByte(); err != nil { 5492 5492 - return err 5493 5493 - } 5494 5494 - 5495 5495 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5496 5496 - if err != nil { 5497 5497 - return err 5498 5498 - } 5499 5499 - 5500 5500 - t.Source = (*string)(&sval) 5501 5501 - } 5502 5502 - } 5503 5503 - // t.Spindle (string) (string) 5504 5504 - case "spindle": 5505 5505 - 5506 5506 - { 5507 5507 - b, err := cr.ReadByte() 5508 5508 - if err != nil { 5509 5509 - return err 5510 5510 - } 5511 5511 - if b != cbg.CborNull[0] { 5512 5512 - if err := cr.UnreadByte(); err != nil { 5513 5513 - return err 5514 5514 - } 5515 5515 - 5516 5516 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5517 5517 - if err != nil { 5518 5518 - return err 5519 5519 - } 5520 5520 - 5521 5521 - t.Spindle = (*string)(&sval) 5522 5522 - } 5523 5523 - } 5524 5271 // t.CreatedAt (string) (string) 5525 5272 case "createdAt": 5526 5273 ··· 5531 5278 } 5532 5279 5533 5280 t.CreatedAt = string(sval) 5534 5534 - } 5535 5535 - // t.Description (string) (string) 5536 5536 - case "description": 5537 5537 - 5538 5538 - { 5539 5539 - b, err := cr.ReadByte() 5540 5540 - if err != nil { 5541 5541 - return err 5542 5542 - } 5543 5543 - if b != cbg.CborNull[0] { 5544 5544 - if err := cr.UnreadByte(); err != nil { 5545 5545 - return err 5546 5546 - } 5547 5547 - 5548 5548 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5549 5549 - if err != nil { 5550 5550 - return err 5551 5551 - } 5552 5552 - 5553 5553 - t.Description = (*string)(&sval) 5554 5554 - } 5555 5281 } 5556 5282 5557 5283 default: ··· 6052 5778 6053 5779 return nil 6054 5780 } 6055 6055 - func (t *RepoIssue) MarshalCBOR(w io.Writer) error { 6056 6056 - if t == nil { 6057 6057 - _, err := w.Write(cbg.CborNull) 6058 6058 - return err 6059 6059 - } 6060 6060 - 6061 6061 - cw := cbg.NewCborWriter(w) 6062 6062 - fieldCount := 7 6063 6063 - 6064 6064 - if t.Body == nil { 6065 6065 - fieldCount-- 6066 6066 - } 6067 6067 - 6068 6068 - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 6069 6069 - return err 6070 6070 - } 6071 6071 - 6072 6072 - // t.Body (string) (string) 6073 6073 - if t.Body != nil { 6074 6074 - 6075 6075 - if len("body") > 1000000 { 6076 6076 - return xerrors.Errorf("Value in field \"body\" was too long") 6077 6077 - } 6078 6078 - 6079 6079 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil { 6080 6080 - return err 6081 6081 - } 6082 6082 - if _, err := cw.WriteString(string("body")); err != nil { 6083 6083 - return err 6084 6084 - } 6085 6085 - 6086 6086 - if t.Body == nil { 6087 6087 - if _, err := cw.Write(cbg.CborNull); err != nil { 6088 6088 - return err 6089 6089 - } 6090 6090 - } else { 6091 6091 - if len(*t.Body) > 1000000 { 6092 6092 - return xerrors.Errorf("Value in field t.Body was too long") 6093 6093 - } 6094 6094 - 6095 6095 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil { 6096 6096 - return err 6097 6097 - } 6098 6098 - if _, err := cw.WriteString(string(*t.Body)); err != nil { 6099 6099 - return err 6100 6100 - } 6101 6101 - } 6102 6102 - } 6103 6103 - 6104 6104 - // t.Repo (string) (string) 6105 6105 - if len("repo") > 1000000 { 6106 6106 - return xerrors.Errorf("Value in field \"repo\" was too long") 6107 6107 - } 6108 6108 - 6109 6109 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 6110 6110 - return err 6111 6111 - } 6112 6112 - if _, err := cw.WriteString(string("repo")); err != nil { 6113 6113 - return err 6114 6114 - } 6115 6115 - 6116 6116 - if len(t.Repo) > 1000000 { 6117 6117 - return xerrors.Errorf("Value in field t.Repo was too long") 6118 6118 - } 6119 6119 - 6120 6120 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 6121 6121 - return err 6122 6122 - } 6123 6123 - if _, err := cw.WriteString(string(t.Repo)); err != nil { 6124 6124 - return err 6125 6125 - } 6126 6126 - 6127 6127 - // t.LexiconTypeID (string) (string) 6128 6128 - if len("$type") > 1000000 { 6129 6129 - return xerrors.Errorf("Value in field \"$type\" was too long") 6130 6130 - } 6131 6131 - 6132 6132 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 6133 6133 - return err 6134 6134 - } 6135 6135 - if _, err := cw.WriteString(string("$type")); err != nil { 6136 6136 - return err 6137 6137 - } 6138 6138 - 6139 6139 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil { 6140 6140 - return err 6141 6141 - } 6142 6142 - if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil { 6143 6143 - return err 6144 6144 - } 6145 6145 - 6146 6146 - // t.Owner (string) (string) 6147 6147 - if len("owner") > 1000000 { 6148 6148 - return xerrors.Errorf("Value in field \"owner\" was too long") 6149 6149 - } 6150 6150 - 6151 6151 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil { 6152 6152 - return err 6153 6153 - } 6154 6154 - if _, err := cw.WriteString(string("owner")); err != nil { 6155 6155 - return err 6156 6156 - } 6157 6157 - 6158 6158 - if len(t.Owner) > 1000000 { 6159 6159 - return xerrors.Errorf("Value in field t.Owner was too long") 6160 6160 - } 6161 6161 - 6162 6162 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil { 6163 6163 - return err 6164 6164 - } 6165 6165 - if _, err := cw.WriteString(string(t.Owner)); err != nil { 6166 6166 - return err 6167 6167 - } 6168 6168 - 6169 6169 - // t.Title (string) (string) 6170 6170 - if len("title") > 1000000 { 6171 6171 - return xerrors.Errorf("Value in field \"title\" was too long") 6172 6172 - } 6173 6173 - 6174 6174 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil { 6175 6175 - return err 6176 6176 - } 6177 6177 - if _, err := cw.WriteString(string("title")); err != nil { 6178 6178 - return err 6179 6179 - } 6180 6180 - 6181 6181 - if len(t.Title) > 1000000 { 6182 6182 - return xerrors.Errorf("Value in field t.Title was too long") 6183 6183 - } 6184 6184 - 6185 6185 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil { 6186 6186 - return err 6187 6187 - } 6188 6188 - if _, err := cw.WriteString(string(t.Title)); err != nil { 6189 6189 - return err 6190 6190 - } 6191 6191 - 6192 6192 - // t.IssueId (int64) (int64) 6193 6193 - if len("issueId") > 1000000 { 6194 6194 - return xerrors.Errorf("Value in field \"issueId\" was too long") 6195 6195 - } 6196 6196 - 6197 6197 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issueId"))); err != nil { 6198 6198 - return err 6199 6199 - } 6200 6200 - if _, err := cw.WriteString(string("issueId")); err != nil { 6201 6201 - return err 6202 6202 - } 6203 6203 - 6204 6204 - if t.IssueId >= 0 { 6205 6205 - if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.IssueId)); err != nil { 6206 6206 - return err 6207 6207 - } 6208 6208 - } else { 6209 6209 - if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.IssueId-1)); err != nil { 6210 6210 - return err 6211 6211 - } 6212 6212 - } 6213 6213 - 6214 6214 - // t.CreatedAt (string) (string) 6215 6215 - if len("createdAt") > 1000000 { 6216 6216 - return xerrors.Errorf("Value in field \"createdAt\" was too long") 6217 6217 - } 6218 6218 - 6219 6219 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 6220 6220 - return err 6221 6221 - } 6222 6222 - if _, err := cw.WriteString(string("createdAt")); err != nil { 6223 6223 - return err 6224 6224 - } 6225 6225 - 6226 6226 - if len(t.CreatedAt) > 1000000 { 6227 6227 - return xerrors.Errorf("Value in field t.CreatedAt was too long") 6228 6228 - } 6229 6229 - 6230 6230 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 6231 6231 - return err 6232 6232 - } 6233 6233 - if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 6234 6234 - return err 6235 6235 - } 6236 6236 - return nil 6237 6237 - } 6238 6238 - 6239 6239 - func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) { 6240 6240 - *t = RepoIssue{} 6241 6241 - 6242 6242 - cr := cbg.NewCborReader(r) 6243 6243 - 6244 6244 - maj, extra, err := cr.ReadHeader() 6245 6245 - if err != nil { 6246 6246 - return err 6247 6247 - } 6248 6248 - defer func() { 6249 6249 - if err == io.EOF { 6250 6250 - err = io.ErrUnexpectedEOF 6251 6251 - } 6252 6252 - }() 6253 6253 - 6254 6254 - if maj != cbg.MajMap { 6255 6255 - return fmt.Errorf("cbor input should be of type map") 6256 6256 - } 6257 6257 - 6258 6258 - if extra > cbg.MaxLength { 6259 6259 - return fmt.Errorf("RepoIssue: map struct too large (%d)", extra) 6260 6260 - } 6261 6261 - 6262 6262 - n := extra 6263 6263 - 6264 6264 - nameBuf := make([]byte, 9) 6265 6265 - for i := uint64(0); i < n; i++ { 6266 6266 - nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6267 6267 - if err != nil { 6268 6268 - return err 6269 6269 - } 6270 6270 - 6271 6271 - if !ok { 6272 6272 - // Field doesn't exist on this type, so ignore it 6273 6273 - if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 6274 6274 - return err 6275 6275 - } 6276 6276 - continue 6277 6277 - } 6278 6278 - 6279 6279 - switch string(nameBuf[:nameLen]) { 6280 6280 - // t.Body (string) (string) 6281 6281 - case "body": 6282 6282 - 6283 6283 - { 6284 6284 - b, err := cr.ReadByte() 6285 6285 - if err != nil { 6286 6286 - return err 6287 6287 - } 6288 6288 - if b != cbg.CborNull[0] { 6289 6289 - if err := cr.UnreadByte(); err != nil { 6290 6290 - return err 6291 6291 - } 6292 6292 - 6293 6293 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6294 6294 - if err != nil { 6295 6295 - return err 6296 6296 - } 6297 6297 - 6298 6298 - t.Body = (*string)(&sval) 6299 6299 - } 6300 6300 - } 6301 6301 - // t.Repo (string) (string) 6302 6302 - case "repo": 6303 6303 - 6304 6304 - { 6305 6305 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6306 6306 - if err != nil { 6307 6307 - return err 6308 6308 - } 6309 6309 - 6310 6310 - t.Repo = string(sval) 6311 6311 - } 6312 6312 - // t.LexiconTypeID (string) (string) 6313 6313 - case "$type": 6314 6314 - 6315 6315 - { 6316 6316 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6317 6317 - if err != nil { 6318 6318 - return err 6319 6319 - } 6320 6320 - 6321 6321 - t.LexiconTypeID = string(sval) 6322 6322 - } 6323 6323 - // t.Owner (string) (string) 6324 6324 - case "owner": 6325 6325 - 6326 6326 - { 6327 6327 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6328 6328 - if err != nil { 6329 6329 - return err 6330 6330 - } 6331 6331 - 6332 6332 - t.Owner = string(sval) 6333 6333 - } 6334 6334 - // t.Title (string) (string) 6335 6335 - case "title": 6336 6336 - 6337 6337 - { 6338 6338 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6339 6339 - if err != nil { 6340 6340 - return err 6341 6341 - } 6342 6342 - 6343 6343 - t.Title = string(sval) 6344 6344 - } 6345 6345 - // t.IssueId (int64) (int64) 6346 6346 - case "issueId": 6347 6347 - { 6348 6348 - maj, extra, err := cr.ReadHeader() 6349 6349 - if err != nil { 6350 6350 - return err 6351 6351 - } 6352 6352 - var extraI int64 6353 6353 - switch maj { 6354 6354 - case cbg.MajUnsignedInt: 6355 6355 - extraI = int64(extra) 6356 6356 - if extraI < 0 { 6357 6357 - return fmt.Errorf("int64 positive overflow") 6358 6358 - } 6359 6359 - case cbg.MajNegativeInt: 6360 6360 - extraI = int64(extra) 6361 6361 - if extraI < 0 { 6362 6362 - return fmt.Errorf("int64 negative overflow") 6363 6363 - } 6364 6364 - extraI = -1 - extraI 6365 6365 - default: 6366 6366 - return fmt.Errorf("wrong type for int64 field: %d", maj) 6367 6367 - } 6368 6368 - 6369 6369 - t.IssueId = int64(extraI) 6370 6370 - } 6371 6371 - // t.CreatedAt (string) (string) 6372 6372 - case "createdAt": 6373 6373 - 6374 6374 - { 6375 6375 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6376 6376 - if err != nil { 6377 6377 - return err 6378 6378 - } 6379 6379 - 6380 6380 - t.CreatedAt = string(sval) 6381 6381 - } 6382 6382 - 6383 6383 - default: 6384 6384 - // Field doesn't exist on this type, so ignore it 6385 6385 - if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 6386 6386 - return err 6387 6387 - } 6388 6388 - } 6389 6389 - } 6390 6390 - 6391 6391 - return nil 6392 6392 - } 6393 5781 func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error { 6394 5782 if t == nil { 6395 5783 _, err := w.Write(cbg.CborNull) ··· 6939 6327 6940 6328 return nil 6941 6329 } 6942 6942 - func (t *RepoPull) MarshalCBOR(w io.Writer) error { 6330 6330 + func (t *RepoIssue) MarshalCBOR(w io.Writer) error { 6943 6331 if t == nil { 6944 6332 _, err := w.Write(cbg.CborNull) 6945 6333 return err 6946 6334 } 6947 6335 6948 6336 cw := cbg.NewCborWriter(w) 6949 6949 - fieldCount := 9 6337 6337 + fieldCount := 7 6950 6338 6951 6339 if t.Body == nil { 6952 6952 - fieldCount-- 6953 6953 - } 6954 6954 - 6955 6955 - if t.Source == nil { 6956 6340 fieldCount-- 6957 6341 } 6958 6342 ··· 6992 6376 } 6993 6377 } 6994 6378 6379 6379 + // t.Repo (string) (string) 6380 6380 + if len("repo") > 1000000 { 6381 6381 + return xerrors.Errorf("Value in field \"repo\" was too long") 6382 6382 + } 6383 6383 + 6384 6384 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 6385 6385 + return err 6386 6386 + } 6387 6387 + if _, err := cw.WriteString(string("repo")); err != nil { 6388 6388 + return err 6389 6389 + } 6390 6390 + 6391 6391 + if len(t.Repo) > 1000000 { 6392 6392 + return xerrors.Errorf("Value in field t.Repo was too long") 6393 6393 + } 6394 6394 + 6395 6395 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 6396 6396 + return err 6397 6397 + } 6398 6398 + if _, err := cw.WriteString(string(t.Repo)); err != nil { 6399 6399 + return err 6400 6400 + } 6401 6401 + 6995 6402 // t.LexiconTypeID (string) (string) 6996 6403 if len("$type") > 1000000 { 6997 6404 return xerrors.Errorf("Value in field \"$type\" was too long") ··· 7004 6411 return err 7005 6412 } 7006 6413 7007 7007 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil { 6414 6414 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil { 7008 6415 return err 7009 6416 } 7010 7010 - if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil { 6417 6417 + if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil { 7011 6418 return err 7012 6419 } 7013 6420 7014 7014 - // t.Patch (string) (string) 7015 7015 - if len("patch") > 1000000 { 7016 7016 - return xerrors.Errorf("Value in field \"patch\" was too long") 6421 6421 + // t.Owner (string) (string) 6422 6422 + if len("owner") > 1000000 { 6423 6423 + return xerrors.Errorf("Value in field \"owner\" was too long") 7017 6424 } 7018 6425 7019 7019 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil { 6426 6426 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil { 7020 6427 return err 7021 6428 } 7022 7022 - if _, err := cw.WriteString(string("patch")); err != nil { 6429 6429 + if _, err := cw.WriteString(string("owner")); err != nil { 7023 6430 return err 7024 6431 } 7025 6432 7026 7026 - if len(t.Patch) > 1000000 { 7027 7027 - return xerrors.Errorf("Value in field t.Patch was too long") 6433 6433 + if len(t.Owner) > 1000000 { 6434 6434 + return xerrors.Errorf("Value in field t.Owner was too long") 7028 6435 } 7029 6436 7030 7030 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Patch))); err != nil { 6437 6437 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil { 7031 6438 return err 7032 6439 } 7033 7033 - if _, err := cw.WriteString(string(t.Patch)); err != nil { 6440 6440 + if _, err := cw.WriteString(string(t.Owner)); err != nil { 7034 6441 return err 7035 6442 } 7036 6443 ··· 7057 6464 return err 7058 6465 } 7059 6466 7060 7060 - // t.PullId (int64) (int64) 7061 7061 - if len("pullId") > 1000000 { 7062 7062 - return xerrors.Errorf("Value in field \"pullId\" was too long") 6467 6467 + // t.IssueId (int64) (int64) 6468 6468 + if len("issueId") > 1000000 { 6469 6469 + return xerrors.Errorf("Value in field \"issueId\" was too long") 7063 6470 } 7064 6471 7065 7065 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullId"))); err != nil { 6472 6472 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issueId"))); err != nil { 7066 6473 return err 7067 6474 } 7068 7068 - if _, err := cw.WriteString(string("pullId")); err != nil { 6475 6475 + if _, err := cw.WriteString(string("issueId")); err != nil { 7069 6476 return err 7070 6477 } 7071 6478 7072 7072 - if t.PullId >= 0 { 7073 7073 - if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.PullId)); err != nil { 6479 6479 + if t.IssueId >= 0 { 6480 6480 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.IssueId)); err != nil { 7074 6481 return err 7075 6482 } 7076 6483 } else { 7077 7077 - if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.PullId-1)); err != nil { 7078 7078 - return err 7079 7079 - } 7080 7080 - } 7081 7081 - 7082 7082 - // t.Source (tangled.RepoPull_Source) (struct) 7083 7083 - if t.Source != nil { 7084 7084 - 7085 7085 - if len("source") > 1000000 { 7086 7086 - return xerrors.Errorf("Value in field \"source\" was too long") 7087 7087 - } 7088 7088 - 7089 7089 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil { 7090 7090 - return err 7091 7091 - } 7092 7092 - if _, err := cw.WriteString(string("source")); err != nil { 7093 7093 - return err 7094 7094 - } 7095 7095 - 7096 7096 - if err := t.Source.MarshalCBOR(cw); err != nil { 6484 6484 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.IssueId-1)); err != nil { 7097 6485 return err 7098 6486 } 7099 6487 } ··· 7120 6508 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 7121 6509 return err 7122 6510 } 7123 7123 - 7124 7124 - // t.TargetRepo (string) (string) 7125 7125 - if len("targetRepo") > 1000000 { 7126 7126 - return xerrors.Errorf("Value in field \"targetRepo\" was too long") 7127 7127 - } 7128 7128 - 7129 7129 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetRepo"))); err != nil { 7130 7130 - return err 7131 7131 - } 7132 7132 - if _, err := cw.WriteString(string("targetRepo")); err != nil { 7133 7133 - return err 7134 7134 - } 7135 7135 - 7136 7136 - if len(t.TargetRepo) > 1000000 { 7137 7137 - return xerrors.Errorf("Value in field t.TargetRepo was too long") 7138 7138 - } 7139 7139 - 7140 7140 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetRepo))); err != nil { 7141 7141 - return err 7142 7142 - } 7143 7143 - if _, err := cw.WriteString(string(t.TargetRepo)); err != nil { 7144 7144 - return err 7145 7145 - } 7146 7146 - 7147 7147 - // t.TargetBranch (string) (string) 7148 7148 - if len("targetBranch") > 1000000 { 7149 7149 - return xerrors.Errorf("Value in field \"targetBranch\" was too long") 7150 7150 - } 7151 7151 - 7152 7152 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil { 7153 7153 - return err 7154 7154 - } 7155 7155 - if _, err := cw.WriteString(string("targetBranch")); err != nil { 7156 7156 - return err 7157 7157 - } 7158 7158 - 7159 7159 - if len(t.TargetBranch) > 1000000 { 7160 7160 - return xerrors.Errorf("Value in field t.TargetBranch was too long") 7161 7161 - } 7162 7162 - 7163 7163 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil { 7164 7164 - return err 7165 7165 - } 7166 7166 - if _, err := cw.WriteString(string(t.TargetBranch)); err != nil { 7167 7167 - return err 7168 7168 - } 7169 6511 return nil 7170 6512 } 7171 6513 7172 7172 - func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) { 7173 7173 - *t = RepoPull{} 6514 6514 + func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) { 6515 6515 + *t = RepoIssue{} 7174 6516 7175 6517 cr := cbg.NewCborReader(r) 7176 6518 ··· 7189 6531 } 7190 6532 7191 6533 if extra > cbg.MaxLength { 7192 7192 - return fmt.Errorf("RepoPull: map struct too large (%d)", extra) 6534 6534 + return fmt.Errorf("RepoIssue: map struct too large (%d)", extra) 7193 6535 } 7194 6536 7195 6537 n := extra 7196 6538 7197 7197 - nameBuf := make([]byte, 12) 6539 6539 + nameBuf := make([]byte, 9) 7198 6540 for i := uint64(0); i < n; i++ { 7199 6541 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 7200 6542 if err != nil { ··· 7231 6573 t.Body = (*string)(&sval) 7232 6574 } 7233 6575 } 6576 6576 + // t.Repo (string) (string) 6577 6577 + case "repo": 6578 6578 + 6579 6579 + { 6580 6580 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 6581 6581 + if err != nil { 6582 6582 + return err 6583 6583 + } 6584 6584 + 6585 6585 + t.Repo = string(sval) 6586 6586 + } 7234 6587 // t.LexiconTypeID (string) (string) 7235 6588 case "$type": 7236 6589 ··· 7242 6595 7243 6596 t.LexiconTypeID = string(sval) 7244 6597 } 7245 7245 - // t.Patch (string) (string) 7246 7246 - case "patch": 6598 6598 + // t.Owner (string) (string) 6599 6599 + case "owner": 7247 6600 7248 6601 { 7249 6602 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 7251 6604 return err 7252 6605 } 7253 6606 7254 7254 - t.Patch = string(sval) 6607 6607 + t.Owner = string(sval) 7255 6608 } 7256 6609 // t.Title (string) (string) 7257 6610 case "title": ··· 7264 6617 7265 6618 t.Title = string(sval) 7266 6619 } 7267 7267 - // t.PullId (int64) (int64) 7268 7268 - case "pullId": 6620 6620 + // t.IssueId (int64) (int64) 6621 6621 + case "issueId": 7269 6622 { 7270 6623 maj, extra, err := cr.ReadHeader() 7271 6624 if err != nil { ··· 7288 6641 return fmt.Errorf("wrong type for int64 field: %d", maj) 7289 6642 } 7290 6643 7291 7291 - t.PullId = int64(extraI) 7292 7292 - } 7293 7293 - // t.Source (tangled.RepoPull_Source) (struct) 7294 7294 - case "source": 7295 7295 - 7296 7296 - { 7297 7297 - 7298 7298 - b, err := cr.ReadByte() 7299 7299 - if err != nil { 7300 7300 - return err 7301 7301 - } 7302 7302 - if b != cbg.CborNull[0] { 7303 7303 - if err := cr.UnreadByte(); err != nil { 7304 7304 - return err 7305 7305 - } 7306 7306 - t.Source = new(RepoPull_Source) 7307 7307 - if err := t.Source.UnmarshalCBOR(cr); err != nil { 7308 7308 - return xerrors.Errorf("unmarshaling t.Source pointer: %w", err) 7309 7309 - } 7310 7310 - } 7311 7311 - 6644 6644 + t.IssueId = int64(extraI) 7312 6645 } 7313 6646 // t.CreatedAt (string) (string) 7314 6647 case "createdAt": ··· 7321 6654 7322 6655 t.CreatedAt = string(sval) 7323 6656 } 7324 7324 - // t.TargetRepo (string) (string) 7325 7325 - case "targetRepo": 7326 7326 - 7327 7327 - { 7328 7328 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 7329 7329 - if err != nil { 7330 7330 - return err 7331 7331 - } 7332 7332 - 7333 7333 - t.TargetRepo = string(sval) 7334 7334 - } 7335 7335 - // t.TargetBranch (string) (string) 7336 7336 - case "targetBranch": 7337 7337 - 7338 7338 - { 7339 7339 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 7340 7340 - if err != nil { 7341 7341 - return err 7342 7342 - } 7343 7343 - 7344 7344 - t.TargetBranch = string(sval) 7345 7345 - } 7346 6657 7347 6658 default: 7348 6659 // Field doesn't exist on this type, so ignore it ··· 7739 7050 7740 7051 return nil 7741 7052 } 7053 7053 + func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error { 7054 7054 + if t == nil { 7055 7055 + _, err := w.Write(cbg.CborNull) 7056 7056 + return err 7057 7057 + } 7058 7058 + 7059 7059 + cw := cbg.NewCborWriter(w) 7060 7060 + 7061 7061 + if _, err := cw.Write([]byte{163}); err != nil { 7062 7062 + return err 7063 7063 + } 7064 7064 + 7065 7065 + // t.Pull (string) (string) 7066 7066 + if len("pull") > 1000000 { 7067 7067 + return xerrors.Errorf("Value in field \"pull\" was too long") 7068 7068 + } 7069 7069 + 7070 7070 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil { 7071 7071 + return err 7072 7072 + } 7073 7073 + if _, err := cw.WriteString(string("pull")); err != nil { 7074 7074 + return err 7075 7075 + } 7076 7076 + 7077 7077 + if len(t.Pull) > 1000000 { 7078 7078 + return xerrors.Errorf("Value in field t.Pull was too long") 7079 7079 + } 7080 7080 + 7081 7081 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil { 7082 7082 + return err 7083 7083 + } 7084 7084 + if _, err := cw.WriteString(string(t.Pull)); err != nil { 7085 7085 + return err 7086 7086 + } 7087 7087 + 7088 7088 + // t.LexiconTypeID (string) (string) 7089 7089 + if len("$type") > 1000000 { 7090 7090 + return xerrors.Errorf("Value in field \"$type\" was too long") 7091 7091 + } 7092 7092 + 7093 7093 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 7094 7094 + return err 7095 7095 + } 7096 7096 + if _, err := cw.WriteString(string("$type")); err != nil { 7097 7097 + return err 7098 7098 + } 7099 7099 + 7100 7100 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil { 7101 7101 + return err 7102 7102 + } 7103 7103 + if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil { 7104 7104 + return err 7105 7105 + } 7106 7106 + 7107 7107 + // t.Status (string) (string) 7108 7108 + if len("status") > 1000000 { 7109 7109 + return xerrors.Errorf("Value in field \"status\" was too long") 7110 7110 + } 7111 7111 + 7112 7112 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil { 7113 7113 + return err 7114 7114 + } 7115 7115 + if _, err := cw.WriteString(string("status")); err != nil { 7116 7116 + return err 7117 7117 + } 7118 7118 + 7119 7119 + if len(t.Status) > 1000000 { 7120 7120 + return xerrors.Errorf("Value in field t.Status was too long") 7121 7121 + } 7122 7122 + 7123 7123 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil { 7124 7124 + return err 7125 7125 + } 7126 7126 + if _, err := cw.WriteString(string(t.Status)); err != nil { 7127 7127 + return err 7128 7128 + } 7129 7129 + return nil 7130 7130 + } 7131 7131 + 7132 7132 + func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) { 7133 7133 + *t = RepoPullStatus{} 7134 7134 + 7135 7135 + cr := cbg.NewCborReader(r) 7136 7136 + 7137 7137 + maj, extra, err := cr.ReadHeader() 7138 7138 + if err != nil { 7139 7139 + return err 7140 7140 + } 7141 7141 + defer func() { 7142 7142 + if err == io.EOF { 7143 7143 + err = io.ErrUnexpectedEOF 7144 7144 + } 7145 7145 + }() 7146 7146 + 7147 7147 + if maj != cbg.MajMap { 7148 7148 + return fmt.Errorf("cbor input should be of type map") 7149 7149 + } 7150 7150 + 7151 7151 + if extra > cbg.MaxLength { 7152 7152 + return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra) 7153 7153 + } 7154 7154 + 7155 7155 + n := extra 7156 7156 + 7157 7157 + nameBuf := make([]byte, 6) 7158 7158 + for i := uint64(0); i < n; i++ { 7159 7159 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 7160 7160 + if err != nil { 7161 7161 + return err 7162 7162 + } 7163 7163 + 7164 7164 + if !ok { 7165 7165 + // Field doesn't exist on this type, so ignore it 7166 7166 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 7167 7167 + return err 7168 7168 + } 7169 7169 + continue 7170 7170 + } 7171 7171 + 7172 7172 + switch string(nameBuf[:nameLen]) { 7173 7173 + // t.Pull (string) (string) 7174 7174 + case "pull": 7175 7175 + 7176 7176 + { 7177 7177 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7178 7178 + if err != nil { 7179 7179 + return err 7180 7180 + } 7181 7181 + 7182 7182 + t.Pull = string(sval) 7183 7183 + } 7184 7184 + // t.LexiconTypeID (string) (string) 7185 7185 + case "$type": 7186 7186 + 7187 7187 + { 7188 7188 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7189 7189 + if err != nil { 7190 7190 + return err 7191 7191 + } 7192 7192 + 7193 7193 + t.LexiconTypeID = string(sval) 7194 7194 + } 7195 7195 + // t.Status (string) (string) 7196 7196 + case "status": 7197 7197 + 7198 7198 + { 7199 7199 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7200 7200 + if err != nil { 7201 7201 + return err 7202 7202 + } 7203 7203 + 7204 7204 + t.Status = string(sval) 7205 7205 + } 7206 7206 + 7207 7207 + default: 7208 7208 + // Field doesn't exist on this type, so ignore it 7209 7209 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 7210 7210 + return err 7211 7211 + } 7212 7212 + } 7213 7213 + } 7214 7214 + 7215 7215 + return nil 7216 7216 + } 7742 7217 func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error { 7743 7218 if t == nil { 7744 7219 _, err := w.Write(cbg.CborNull) ··· 7931 7406 7932 7407 return nil 7933 7408 } 7934 7934 - func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error { 7409 7409 + func (t *RepoPull) MarshalCBOR(w io.Writer) error { 7935 7410 if t == nil { 7936 7411 _, err := w.Write(cbg.CborNull) 7937 7412 return err 7938 7413 } 7939 7414 7940 7415 cw := cbg.NewCborWriter(w) 7416 7416 + fieldCount := 9 7941 7417 7942 7942 - if _, err := cw.Write([]byte{163}); err != nil { 7418 7418 + if t.Body == nil { 7419 7419 + fieldCount-- 7420 7420 + } 7421 7421 + 7422 7422 + if t.Source == nil { 7423 7423 + fieldCount-- 7424 7424 + } 7425 7425 + 7426 7426 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 7943 7427 return err 7944 7428 } 7945 7429 7946 7946 - // t.Pull (string) (string) 7947 7947 - if len("pull") > 1000000 { 7948 7948 - return xerrors.Errorf("Value in field \"pull\" was too long") 7430 7430 + // t.Body (string) (string) 7431 7431 + if t.Body != nil { 7432 7432 + 7433 7433 + if len("body") > 1000000 { 7434 7434 + return xerrors.Errorf("Value in field \"body\" was too long") 7435 7435 + } 7436 7436 + 7437 7437 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil { 7438 7438 + return err 7439 7439 + } 7440 7440 + if _, err := cw.WriteString(string("body")); err != nil { 7441 7441 + return err 7442 7442 + } 7443 7443 + 7444 7444 + if t.Body == nil { 7445 7445 + if _, err := cw.Write(cbg.CborNull); err != nil { 7446 7446 + return err 7447 7447 + } 7448 7448 + } else { 7449 7449 + if len(*t.Body) > 1000000 { 7450 7450 + return xerrors.Errorf("Value in field t.Body was too long") 7451 7451 + } 7452 7452 + 7453 7453 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil { 7454 7454 + return err 7455 7455 + } 7456 7456 + if _, err := cw.WriteString(string(*t.Body)); err != nil { 7457 7457 + return err 7458 7458 + } 7459 7459 + } 7949 7460 } 7950 7461 7951 7951 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil { 7462 7462 + // t.LexiconTypeID (string) (string) 7463 7463 + if len("$type") > 1000000 { 7464 7464 + return xerrors.Errorf("Value in field \"$type\" was too long") 7465 7465 + } 7466 7466 + 7467 7467 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 7952 7468 return err 7953 7469 } 7954 7954 - if _, err := cw.WriteString(string("pull")); err != nil { 7470 7470 + if _, err := cw.WriteString(string("$type")); err != nil { 7471 7471 + return err 7472 7472 + } 7473 7473 + 7474 7474 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil { 7475 7475 + return err 7476 7476 + } 7477 7477 + if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil { 7955 7478 return err 7956 7479 } 7957 7480 7958 7958 - if len(t.Pull) > 1000000 { 7959 7959 - return xerrors.Errorf("Value in field t.Pull was too long") 7481 7481 + // t.Patch (string) (string) 7482 7482 + if len("patch") > 1000000 { 7483 7483 + return xerrors.Errorf("Value in field \"patch\" was too long") 7960 7484 } 7961 7485 7962 7962 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil { 7486 7486 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil { 7963 7487 return err 7964 7488 } 7965 7965 - if _, err := cw.WriteString(string(t.Pull)); err != nil { 7489 7489 + if _, err := cw.WriteString(string("patch")); err != nil { 7966 7490 return err 7967 7491 } 7968 7492 7969 7969 - // t.LexiconTypeID (string) (string) 7970 7970 - if len("$type") > 1000000 { 7971 7971 - return xerrors.Errorf("Value in field \"$type\" was too long") 7493 7493 + if len(t.Patch) > 1000000 { 7494 7494 + return xerrors.Errorf("Value in field t.Patch was too long") 7972 7495 } 7973 7496 7974 7974 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 7497 7497 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Patch))); err != nil { 7975 7498 return err 7976 7499 } 7977 7977 - if _, err := cw.WriteString(string("$type")); err != nil { 7500 7500 + if _, err := cw.WriteString(string(t.Patch)); err != nil { 7978 7501 return err 7979 7502 } 7980 7503 7981 7981 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil { 7504 7504 + // t.Title (string) (string) 7505 7505 + if len("title") > 1000000 { 7506 7506 + return xerrors.Errorf("Value in field \"title\" was too long") 7507 7507 + } 7508 7508 + 7509 7509 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil { 7982 7510 return err 7983 7511 } 7984 7984 - if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil { 7512 7512 + if _, err := cw.WriteString(string("title")); err != nil { 7985 7513 return err 7986 7514 } 7987 7515 7988 7988 - // t.Status (string) (string) 7989 7989 - if len("status") > 1000000 { 7990 7990 - return xerrors.Errorf("Value in field \"status\" was too long") 7516 7516 + if len(t.Title) > 1000000 { 7517 7517 + return xerrors.Errorf("Value in field t.Title was too long") 7991 7518 } 7992 7519 7993 7993 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil { 7520 7520 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil { 7994 7521 return err 7995 7522 } 7996 7996 - if _, err := cw.WriteString(string("status")); err != nil { 7523 7523 + if _, err := cw.WriteString(string(t.Title)); err != nil { 7997 7524 return err 7998 7525 } 7999 7526 8000 8000 - if len(t.Status) > 1000000 { 8001 8001 - return xerrors.Errorf("Value in field t.Status was too long") 7527 7527 + // t.PullId (int64) (int64) 7528 7528 + if len("pullId") > 1000000 { 7529 7529 + return xerrors.Errorf("Value in field \"pullId\" was too long") 8002 7530 } 8003 7531 8004 8004 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil { 7532 7532 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullId"))); err != nil { 8005 7533 return err 8006 7534 } 8007 8007 - if _, err := cw.WriteString(string(t.Status)); err != nil { 7535 7535 + if _, err := cw.WriteString(string("pullId")); err != nil { 7536 7536 + return err 7537 7537 + } 7538 7538 + 7539 7539 + if t.PullId >= 0 { 7540 7540 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.PullId)); err != nil { 7541 7541 + return err 7542 7542 + } 7543 7543 + } else { 7544 7544 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.PullId-1)); err != nil { 7545 7545 + return err 7546 7546 + } 7547 7547 + } 7548 7548 + 7549 7549 + // t.Source (tangled.RepoPull_Source) (struct) 7550 7550 + if t.Source != nil { 7551 7551 + 7552 7552 + if len("source") > 1000000 { 7553 7553 + return xerrors.Errorf("Value in field \"source\" was too long") 7554 7554 + } 7555 7555 + 7556 7556 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil { 7557 7557 + return err 7558 7558 + } 7559 7559 + if _, err := cw.WriteString(string("source")); err != nil { 7560 7560 + return err 7561 7561 + } 7562 7562 + 7563 7563 + if err := t.Source.MarshalCBOR(cw); err != nil { 7564 7564 + return err 7565 7565 + } 7566 7566 + } 7567 7567 + 7568 7568 + // t.CreatedAt (string) (string) 7569 7569 + if len("createdAt") > 1000000 { 7570 7570 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 7571 7571 + } 7572 7572 + 7573 7573 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 7574 7574 + return err 7575 7575 + } 7576 7576 + if _, err := cw.WriteString(string("createdAt")); err != nil { 7577 7577 + return err 7578 7578 + } 7579 7579 + 7580 7580 + if len(t.CreatedAt) > 1000000 { 7581 7581 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 7582 7582 + } 7583 7583 + 7584 7584 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 7585 7585 + return err 7586 7586 + } 7587 7587 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 7588 7588 + return err 7589 7589 + } 7590 7590 + 7591 7591 + // t.TargetRepo (string) (string) 7592 7592 + if len("targetRepo") > 1000000 { 7593 7593 + return xerrors.Errorf("Value in field \"targetRepo\" was too long") 7594 7594 + } 7595 7595 + 7596 7596 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetRepo"))); err != nil { 7597 7597 + return err 7598 7598 + } 7599 7599 + if _, err := cw.WriteString(string("targetRepo")); err != nil { 7600 7600 + return err 7601 7601 + } 7602 7602 + 7603 7603 + if len(t.TargetRepo) > 1000000 { 7604 7604 + return xerrors.Errorf("Value in field t.TargetRepo was too long") 7605 7605 + } 7606 7606 + 7607 7607 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetRepo))); err != nil { 7608 7608 + return err 7609 7609 + } 7610 7610 + if _, err := cw.WriteString(string(t.TargetRepo)); err != nil { 7611 7611 + return err 7612 7612 + } 7613 7613 + 7614 7614 + // t.TargetBranch (string) (string) 7615 7615 + if len("targetBranch") > 1000000 { 7616 7616 + return xerrors.Errorf("Value in field \"targetBranch\" was too long") 7617 7617 + } 7618 7618 + 7619 7619 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil { 7620 7620 + return err 7621 7621 + } 7622 7622 + if _, err := cw.WriteString(string("targetBranch")); err != nil { 7623 7623 + return err 7624 7624 + } 7625 7625 + 7626 7626 + if len(t.TargetBranch) > 1000000 { 7627 7627 + return xerrors.Errorf("Value in field t.TargetBranch was too long") 7628 7628 + } 7629 7629 + 7630 7630 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil { 7631 7631 + return err 7632 7632 + } 7633 7633 + if _, err := cw.WriteString(string(t.TargetBranch)); err != nil { 8008 7634 return err 8009 7635 } 8010 7636 return nil 8011 7637 } 8012 7638 8013 8013 - func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) { 8014 8014 - *t = RepoPullStatus{} 7639 7639 + func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) { 7640 7640 + *t = RepoPull{} 8015 7641 8016 7642 cr := cbg.NewCborReader(r) 8017 7643 ··· 8030 7656 } 8031 7657 8032 7658 if extra > cbg.MaxLength { 8033 8033 - return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra) 7659 7659 + return fmt.Errorf("RepoPull: map struct too large (%d)", extra) 8034 7660 } 8035 7661 8036 7662 n := extra 8037 7663 8038 8038 - nameBuf := make([]byte, 6) 7664 7664 + nameBuf := make([]byte, 12) 8039 7665 for i := uint64(0); i < n; i++ { 8040 7666 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 8041 7667 if err != nil { ··· 8051 7677 } 8052 7678 8053 7679 switch string(nameBuf[:nameLen]) { 8054 8054 - // t.Pull (string) (string) 8055 8055 - case "pull": 7680 7680 + // t.Body (string) (string) 7681 7681 + case "body": 8056 7682 8057 7683 { 8058 8058 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 7684 7684 + b, err := cr.ReadByte() 8059 7685 if err != nil { 8060 7686 return err 8061 7687 } 7688 7688 + if b != cbg.CborNull[0] { 7689 7689 + if err := cr.UnreadByte(); err != nil { 7690 7690 + return err 7691 7691 + } 8062 7692 8063 8063 - t.Pull = string(sval) 7693 7693 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7694 7694 + if err != nil { 7695 7695 + return err 7696 7696 + } 7697 7697 + 7698 7698 + t.Body = (*string)(&sval) 7699 7699 + } 8064 7700 } 8065 7701 // t.LexiconTypeID (string) (string) 8066 7702 case "$type": ··· 8073 7709 8074 7710 t.LexiconTypeID = string(sval) 8075 7711 } 8076 8076 - // t.Status (string) (string) 8077 8077 - case "status": 7712 7712 + // t.Patch (string) (string) 7713 7713 + case "patch": 7714 7714 + 7715 7715 + { 7716 7716 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7717 7717 + if err != nil { 7718 7718 + return err 7719 7719 + } 7720 7720 + 7721 7721 + t.Patch = string(sval) 7722 7722 + } 7723 7723 + // t.Title (string) (string) 7724 7724 + case "title": 7725 7725 + 7726 7726 + { 7727 7727 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7728 7728 + if err != nil { 7729 7729 + return err 7730 7730 + } 7731 7731 + 7732 7732 + t.Title = string(sval) 7733 7733 + } 7734 7734 + // t.PullId (int64) (int64) 7735 7735 + case "pullId": 7736 7736 + { 7737 7737 + maj, extra, err := cr.ReadHeader() 7738 7738 + if err != nil { 7739 7739 + return err 7740 7740 + } 7741 7741 + var extraI int64 7742 7742 + switch maj { 7743 7743 + case cbg.MajUnsignedInt: 7744 7744 + extraI = int64(extra) 7745 7745 + if extraI < 0 { 7746 7746 + return fmt.Errorf("int64 positive overflow") 7747 7747 + } 7748 7748 + case cbg.MajNegativeInt: 7749 7749 + extraI = int64(extra) 7750 7750 + if extraI < 0 { 7751 7751 + return fmt.Errorf("int64 negative overflow") 7752 7752 + } 7753 7753 + extraI = -1 - extraI 7754 7754 + default: 7755 7755 + return fmt.Errorf("wrong type for int64 field: %d", maj) 7756 7756 + } 7757 7757 + 7758 7758 + t.PullId = int64(extraI) 7759 7759 + } 7760 7760 + // t.Source (tangled.RepoPull_Source) (struct) 7761 7761 + case "source": 7762 7762 + 7763 7763 + { 7764 7764 + 7765 7765 + b, err := cr.ReadByte() 7766 7766 + if err != nil { 7767 7767 + return err 7768 7768 + } 7769 7769 + if b != cbg.CborNull[0] { 7770 7770 + if err := cr.UnreadByte(); err != nil { 7771 7771 + return err 7772 7772 + } 7773 7773 + t.Source = new(RepoPull_Source) 7774 7774 + if err := t.Source.UnmarshalCBOR(cr); err != nil { 7775 7775 + return xerrors.Errorf("unmarshaling t.Source pointer: %w", err) 7776 7776 + } 7777 7777 + } 7778 7778 + 7779 7779 + } 7780 7780 + // t.CreatedAt (string) (string) 7781 7781 + case "createdAt": 8078 7782 8079 7783 { 8080 7784 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 8082 7786 return err 8083 7787 } 8084 7788 8085 8085 - t.Status = string(sval) 7789 7789 + t.CreatedAt = string(sval) 7790 7790 + } 7791 7791 + // t.TargetRepo (string) (string) 7792 7792 + case "targetRepo": 7793 7793 + 7794 7794 + { 7795 7795 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7796 7796 + if err != nil { 7797 7797 + return err 7798 7798 + } 7799 7799 + 7800 7800 + t.TargetRepo = string(sval) 7801 7801 + } 7802 7802 + // t.TargetBranch (string) (string) 7803 7803 + case "targetBranch": 7804 7804 + 7805 7805 + { 7806 7806 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7807 7807 + if err != nil { 7808 7808 + return err 7809 7809 + } 7810 7810 + 7811 7811 + t.TargetBranch = string(sval) 8086 7812 } 8087 7813 8088 7814 default: ··· 8095 7821 8096 7822 return nil 8097 7823 } 8098 8098 - func (t *Spindle) MarshalCBOR(w io.Writer) error { 7824 7824 + func (t *Repo) MarshalCBOR(w io.Writer) error { 8099 7825 if t == nil { 8100 7826 _, err := w.Write(cbg.CborNull) 8101 7827 return err 8102 7828 } 8103 7829 8104 7830 cw := cbg.NewCborWriter(w) 7831 7831 + fieldCount := 8 8105 7832 8106 8106 - if _, err := cw.Write([]byte{162}); err != nil { 7833 7833 + if t.Description == nil { 7834 7834 + fieldCount-- 7835 7835 + } 7836 7836 + 7837 7837 + if t.Source == nil { 7838 7838 + fieldCount-- 7839 7839 + } 7840 7840 + 7841 7841 + if t.Spindle == nil { 7842 7842 + fieldCount-- 7843 7843 + } 7844 7844 + 7845 7845 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 7846 7846 + return err 7847 7847 + } 7848 7848 + 7849 7849 + // t.Knot (string) (string) 7850 7850 + if len("knot") > 1000000 { 7851 7851 + return xerrors.Errorf("Value in field \"knot\" was too long") 7852 7852 + } 7853 7853 + 7854 7854 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil { 7855 7855 + return err 7856 7856 + } 7857 7857 + if _, err := cw.WriteString(string("knot")); err != nil { 7858 7858 + return err 7859 7859 + } 7860 7860 + 7861 7861 + if len(t.Knot) > 1000000 { 7862 7862 + return xerrors.Errorf("Value in field t.Knot was too long") 7863 7863 + } 7864 7864 + 7865 7865 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil { 7866 7866 + return err 7867 7867 + } 7868 7868 + if _, err := cw.WriteString(string(t.Knot)); err != nil { 7869 7869 + return err 7870 7870 + } 7871 7871 + 7872 7872 + // t.Name (string) (string) 7873 7873 + if len("name") > 1000000 { 7874 7874 + return xerrors.Errorf("Value in field \"name\" was too long") 7875 7875 + } 7876 7876 + 7877 7877 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 7878 7878 + return err 7879 7879 + } 7880 7880 + if _, err := cw.WriteString(string("name")); err != nil { 7881 7881 + return err 7882 7882 + } 7883 7883 + 7884 7884 + if len(t.Name) > 1000000 { 7885 7885 + return xerrors.Errorf("Value in field t.Name was too long") 7886 7886 + } 7887 7887 + 7888 7888 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 7889 7889 + return err 7890 7890 + } 7891 7891 + if _, err := cw.WriteString(string(t.Name)); err != nil { 8107 7892 return err 8108 7893 } 8109 7894 ··· 8119 7904 return err 8120 7905 } 8121 7906 8122 8122 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle"))); err != nil { 7907 7907 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil { 8123 7908 return err 8124 7909 } 8125 8125 - if _, err := cw.WriteString(string("sh.tangled.spindle")); err != nil { 7910 7910 + if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil { 8126 7911 return err 8127 7912 } 8128 7913 7914 7914 + // t.Owner (string) (string) 7915 7915 + if len("owner") > 1000000 { 7916 7916 + return xerrors.Errorf("Value in field \"owner\" was too long") 7917 7917 + } 7918 7918 + 7919 7919 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil { 7920 7920 + return err 7921 7921 + } 7922 7922 + if _, err := cw.WriteString(string("owner")); err != nil { 7923 7923 + return err 7924 7924 + } 7925 7925 + 7926 7926 + if len(t.Owner) > 1000000 { 7927 7927 + return xerrors.Errorf("Value in field t.Owner was too long") 7928 7928 + } 7929 7929 + 7930 7930 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil { 7931 7931 + return err 7932 7932 + } 7933 7933 + if _, err := cw.WriteString(string(t.Owner)); err != nil { 7934 7934 + return err 7935 7935 + } 7936 7936 + 7937 7937 + // t.Source (string) (string) 7938 7938 + if t.Source != nil { 7939 7939 + 7940 7940 + if len("source") > 1000000 { 7941 7941 + return xerrors.Errorf("Value in field \"source\" was too long") 7942 7942 + } 7943 7943 + 7944 7944 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil { 7945 7945 + return err 7946 7946 + } 7947 7947 + if _, err := cw.WriteString(string("source")); err != nil { 7948 7948 + return err 7949 7949 + } 7950 7950 + 7951 7951 + if t.Source == nil { 7952 7952 + if _, err := cw.Write(cbg.CborNull); err != nil { 7953 7953 + return err 7954 7954 + } 7955 7955 + } else { 7956 7956 + if len(*t.Source) > 1000000 { 7957 7957 + return xerrors.Errorf("Value in field t.Source was too long") 7958 7958 + } 7959 7959 + 7960 7960 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil { 7961 7961 + return err 7962 7962 + } 7963 7963 + if _, err := cw.WriteString(string(*t.Source)); err != nil { 7964 7964 + return err 7965 7965 + } 7966 7966 + } 7967 7967 + } 7968 7968 + 7969 7969 + // t.Spindle (string) (string) 7970 7970 + if t.Spindle != nil { 7971 7971 + 7972 7972 + if len("spindle") > 1000000 { 7973 7973 + return xerrors.Errorf("Value in field \"spindle\" was too long") 7974 7974 + } 7975 7975 + 7976 7976 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("spindle"))); err != nil { 7977 7977 + return err 7978 7978 + } 7979 7979 + if _, err := cw.WriteString(string("spindle")); err != nil { 7980 7980 + return err 7981 7981 + } 7982 7982 + 7983 7983 + if t.Spindle == nil { 7984 7984 + if _, err := cw.Write(cbg.CborNull); err != nil { 7985 7985 + return err 7986 7986 + } 7987 7987 + } else { 7988 7988 + if len(*t.Spindle) > 1000000 { 7989 7989 + return xerrors.Errorf("Value in field t.Spindle was too long") 7990 7990 + } 7991 7991 + 7992 7992 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Spindle))); err != nil { 7993 7993 + return err 7994 7994 + } 7995 7995 + if _, err := cw.WriteString(string(*t.Spindle)); err != nil { 7996 7996 + return err 7997 7997 + } 7998 7998 + } 7999 7999 + } 8000 8000 + 8129 8001 // t.CreatedAt (string) (string) 8130 8002 if len("createdAt") > 1000000 { 8131 8003 return xerrors.Errorf("Value in field \"createdAt\" was too long") ··· 8148 8020 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 8149 8021 return err 8150 8022 } 8023 8023 + 8024 8024 + // t.Description (string) (string) 8025 8025 + if t.Description != nil { 8026 8026 + 8027 8027 + if len("description") > 1000000 { 8028 8028 + return xerrors.Errorf("Value in field \"description\" was too long") 8029 8029 + } 8030 8030 + 8031 8031 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil { 8032 8032 + return err 8033 8033 + } 8034 8034 + if _, err := cw.WriteString(string("description")); err != nil { 8035 8035 + return err 8036 8036 + } 8037 8037 + 8038 8038 + if t.Description == nil { 8039 8039 + if _, err := cw.Write(cbg.CborNull); err != nil { 8040 8040 + return err 8041 8041 + } 8042 8042 + } else { 8043 8043 + if len(*t.Description) > 1000000 { 8044 8044 + return xerrors.Errorf("Value in field t.Description was too long") 8045 8045 + } 8046 8046 + 8047 8047 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil { 8048 8048 + return err 8049 8049 + } 8050 8050 + if _, err := cw.WriteString(string(*t.Description)); err != nil { 8051 8051 + return err 8052 8052 + } 8053 8053 + } 8054 8054 + } 8151 8055 return nil 8152 8056 } 8153 8057 8154 8154 - func (t *Spindle) UnmarshalCBOR(r io.Reader) (err error) { 8155 8155 - *t = Spindle{} 8058 8058 + func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) { 8059 8059 + *t = Repo{} 8156 8060 8157 8061 cr := cbg.NewCborReader(r) 8158 8062 ··· 8171 8075 } 8172 8076 8173 8077 if extra > cbg.MaxLength { 8174 8174 - return fmt.Errorf("Spindle: map struct too large (%d)", extra) 8078 8078 + return fmt.Errorf("Repo: map struct too large (%d)", extra) 8175 8079 } 8176 8080 8177 8081 n := extra 8178 8082 8179 8179 - nameBuf := make([]byte, 9) 8083 8083 + nameBuf := make([]byte, 11) 8180 8084 for i := uint64(0); i < n; i++ { 8181 8085 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 8182 8086 if err != nil { ··· 8192 8096 } 8193 8097 8194 8098 switch string(nameBuf[:nameLen]) { 8195 8195 - // t.LexiconTypeID (string) (string) 8099 8099 + // t.Knot (string) (string) 8100 8100 + case "knot": 8101 8101 + 8102 8102 + { 8103 8103 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8104 8104 + if err != nil { 8105 8105 + return err 8106 8106 + } 8107 8107 + 8108 8108 + t.Knot = string(sval) 8109 8109 + } 8110 8110 + // t.Name (string) (string) 8111 8111 + case "name": 8112 8112 + 8113 8113 + { 8114 8114 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8115 8115 + if err != nil { 8116 8116 + return err 8117 8117 + } 8118 8118 + 8119 8119 + t.Name = string(sval) 8120 8120 + } 8121 8121 + // t.LexiconTypeID (string) (string) 8196 8122 case "$type": 8197 8123 8198 8124 { ··· 8203 8129 8204 8130 t.LexiconTypeID = string(sval) 8205 8131 } 8132 8132 + // t.Owner (string) (string) 8133 8133 + case "owner": 8134 8134 + 8135 8135 + { 8136 8136 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8137 8137 + if err != nil { 8138 8138 + return err 8139 8139 + } 8140 8140 + 8141 8141 + t.Owner = string(sval) 8142 8142 + } 8143 8143 + // t.Source (string) (string) 8144 8144 + case "source": 8145 8145 + 8146 8146 + { 8147 8147 + b, err := cr.ReadByte() 8148 8148 + if err != nil { 8149 8149 + return err 8150 8150 + } 8151 8151 + if b != cbg.CborNull[0] { 8152 8152 + if err := cr.UnreadByte(); err != nil { 8153 8153 + return err 8154 8154 + } 8155 8155 + 8156 8156 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8157 8157 + if err != nil { 8158 8158 + return err 8159 8159 + } 8160 8160 + 8161 8161 + t.Source = (*string)(&sval) 8162 8162 + } 8163 8163 + } 8164 8164 + // t.Spindle (string) (string) 8165 8165 + case "spindle": 8166 8166 + 8167 8167 + { 8168 8168 + b, err := cr.ReadByte() 8169 8169 + if err != nil { 8170 8170 + return err 8171 8171 + } 8172 8172 + if b != cbg.CborNull[0] { 8173 8173 + if err := cr.UnreadByte(); err != nil { 8174 8174 + return err 8175 8175 + } 8176 8176 + 8177 8177 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8178 8178 + if err != nil { 8179 8179 + return err 8180 8180 + } 8181 8181 + 8182 8182 + t.Spindle = (*string)(&sval) 8183 8183 + } 8184 8184 + } 8206 8185 // t.CreatedAt (string) (string) 8207 8186 case "createdAt": 8208 8187 ··· 8213 8192 } 8214 8193 8215 8194 t.CreatedAt = string(sval) 8195 8195 + } 8196 8196 + // t.Description (string) (string) 8197 8197 + case "description": 8198 8198 + 8199 8199 + { 8200 8200 + b, err := cr.ReadByte() 8201 8201 + if err != nil { 8202 8202 + return err 8203 8203 + } 8204 8204 + if b != cbg.CborNull[0] { 8205 8205 + if err := cr.UnreadByte(); err != nil { 8206 8206 + return err 8207 8207 + } 8208 8208 + 8209 8209 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8210 8210 + if err != nil { 8211 8211 + return err 8212 8212 + } 8213 8213 + 8214 8214 + t.Description = (*string)(&sval) 8215 8215 + } 8216 8216 } 8217 8217 8218 8218 default: ··· 8400 8400 } 8401 8401 8402 8402 t.Instance = string(sval) 8403 8403 + } 8404 8404 + // t.CreatedAt (string) (string) 8405 8405 + case "createdAt": 8406 8406 + 8407 8407 + { 8408 8408 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8409 8409 + if err != nil { 8410 8410 + return err 8411 8411 + } 8412 8412 + 8413 8413 + t.CreatedAt = string(sval) 8414 8414 + } 8415 8415 + 8416 8416 + default: 8417 8417 + // Field doesn't exist on this type, so ignore it 8418 8418 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 8419 8419 + return err 8420 8420 + } 8421 8421 + } 8422 8422 + } 8423 8423 + 8424 8424 + return nil 8425 8425 + } 8426 8426 + func (t *Spindle) MarshalCBOR(w io.Writer) error { 8427 8427 + if t == nil { 8428 8428 + _, err := w.Write(cbg.CborNull) 8429 8429 + return err 8430 8430 + } 8431 8431 + 8432 8432 + cw := cbg.NewCborWriter(w) 8433 8433 + 8434 8434 + if _, err := cw.Write([]byte{162}); err != nil { 8435 8435 + return err 8436 8436 + } 8437 8437 + 8438 8438 + // t.LexiconTypeID (string) (string) 8439 8439 + if len("$type") > 1000000 { 8440 8440 + return xerrors.Errorf("Value in field \"$type\" was too long") 8441 8441 + } 8442 8442 + 8443 8443 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 8444 8444 + return err 8445 8445 + } 8446 8446 + if _, err := cw.WriteString(string("$type")); err != nil { 8447 8447 + return err 8448 8448 + } 8449 8449 + 8450 8450 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle"))); err != nil { 8451 8451 + return err 8452 8452 + } 8453 8453 + if _, err := cw.WriteString(string("sh.tangled.spindle")); err != nil { 8454 8454 + return err 8455 8455 + } 8456 8456 + 8457 8457 + // t.CreatedAt (string) (string) 8458 8458 + if len("createdAt") > 1000000 { 8459 8459 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 8460 8460 + } 8461 8461 + 8462 8462 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 8463 8463 + return err 8464 8464 + } 8465 8465 + if _, err := cw.WriteString(string("createdAt")); err != nil { 8466 8466 + return err 8467 8467 + } 8468 8468 + 8469 8469 + if len(t.CreatedAt) > 1000000 { 8470 8470 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 8471 8471 + } 8472 8472 + 8473 8473 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 8474 8474 + return err 8475 8475 + } 8476 8476 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 8477 8477 + return err 8478 8478 + } 8479 8479 + return nil 8480 8480 + } 8481 8481 + 8482 8482 + func (t *Spindle) UnmarshalCBOR(r io.Reader) (err error) { 8483 8483 + *t = Spindle{} 8484 8484 + 8485 8485 + cr := cbg.NewCborReader(r) 8486 8486 + 8487 8487 + maj, extra, err := cr.ReadHeader() 8488 8488 + if err != nil { 8489 8489 + return err 8490 8490 + } 8491 8491 + defer func() { 8492 8492 + if err == io.EOF { 8493 8493 + err = io.ErrUnexpectedEOF 8494 8494 + } 8495 8495 + }() 8496 8496 + 8497 8497 + if maj != cbg.MajMap { 8498 8498 + return fmt.Errorf("cbor input should be of type map") 8499 8499 + } 8500 8500 + 8501 8501 + if extra > cbg.MaxLength { 8502 8502 + return fmt.Errorf("Spindle: map struct too large (%d)", extra) 8503 8503 + } 8504 8504 + 8505 8505 + n := extra 8506 8506 + 8507 8507 + nameBuf := make([]byte, 9) 8508 8508 + for i := uint64(0); i < n; i++ { 8509 8509 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 8510 8510 + if err != nil { 8511 8511 + return err 8512 8512 + } 8513 8513 + 8514 8514 + if !ok { 8515 8515 + // Field doesn't exist on this type, so ignore it 8516 8516 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 8517 8517 + return err 8518 8518 + } 8519 8519 + continue 8520 8520 + } 8521 8521 + 8522 8522 + switch string(nameBuf[:nameLen]) { 8523 8523 + // t.LexiconTypeID (string) (string) 8524 8524 + case "$type": 8525 8525 + 8526 8526 + { 8527 8527 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8528 8528 + if err != nil { 8529 8529 + return err 8530 8530 + } 8531 8531 + 8532 8532 + t.LexiconTypeID = string(sval) 8403 8533 } 8404 8534 // t.CreatedAt (string) (string) 8405 8535 case "createdAt":

+22

api/tangled/tangledknot.go

reviewed

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package tangled 4 4 + 5 5 + // schema: sh.tangled.knot 6 6 + 7 7 + import ( 8 8 + "github.com/bluesky-social/indigo/lex/util" 9 9 + ) 10 10 + 11 11 + const ( 12 12 + KnotNSID = "sh.tangled.knot" 13 13 + ) 14 14 + 15 15 + func init() { 16 16 + util.RegisterType("sh.tangled.knot", &Knot{}) 17 17 + } // 18 18 + // RECORDTYPE: Knot 19 19 + type Knot struct { 20 20 + LexiconTypeID string `json:"$type,const=sh.tangled.knot" cborgen:"$type,const=sh.tangled.knot"` 21 21 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 22 22 + }

+11 -10

cmd/gen.go

reviewed

··· 17 17 tangled.ActorProfile{}, 18 18 tangled.FeedReaction{}, 19 19 tangled.FeedStar{}, 20 20 - tangled.GitRefUpdate{}, 21 21 - tangled.GitRefUpdate_Meta{}, 22 22 - tangled.GitRefUpdate_Meta_CommitCount{}, 23 20 tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem{}, 21 21 + tangled.GitRefUpdate_Meta_CommitCount{}, 24 22 tangled.GitRefUpdate_Meta_LangBreakdown{}, 23 23 + tangled.GitRefUpdate_Meta{}, 25 24 tangled.GitRefUpdate_Pair{}, 25 25 + tangled.GitRefUpdate{}, 26 26 tangled.GraphFollow{}, 27 27 tangled.KnotMember{}, 28 28 - tangled.Pipeline{}, 28 28 + tangled.Knot{}, 29 29 + tangled.PipelineStatus{}, 29 30 tangled.Pipeline_CloneOpts{}, 30 31 tangled.Pipeline_Dependency{}, 31 32 tangled.Pipeline_ManualTriggerData{}, 32 33 tangled.Pipeline_Pair{}, 33 34 tangled.Pipeline_PullRequestTriggerData{}, 34 35 tangled.Pipeline_PushTriggerData{}, 35 35 - tangled.PipelineStatus{}, 36 36 tangled.Pipeline_Step{}, 37 37 tangled.Pipeline_TriggerMetadata{}, 38 38 tangled.Pipeline_TriggerRepo{}, 39 39 tangled.Pipeline_Workflow{}, 40 40 + tangled.Pipeline{}, 40 41 tangled.PublicKey{}, 41 41 - tangled.Repo{}, 42 42 tangled.RepoArtifact{}, 43 43 tangled.RepoCollaborator{}, 44 44 - tangled.RepoIssue{}, 45 44 tangled.RepoIssueComment{}, 46 45 tangled.RepoIssueState{}, 47 47 - tangled.RepoPull{}, 46 46 + tangled.RepoIssue{}, 48 47 tangled.RepoPullComment{}, 49 49 - tangled.RepoPull_Source{}, 50 48 tangled.RepoPullStatus{}, 51 51 - tangled.Spindle{}, 49 49 + tangled.RepoPull_Source{}, 50 50 + tangled.RepoPull{}, 51 51 + tangled.Repo{}, 52 52 tangled.SpindleMember{}, 53 53 + tangled.Spindle{}, 53 54 tangled.String{}, 54 55 ); err != nil { 55 56 panic(err)

+22

lexicons/knot.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.knot", 4 4 + "needsCbor": true, 5 5 + "needsType": true, 6 6 + "defs": { 7 7 + "main": { 8 8 + "type": "record", 9 9 + "key": "any", 10 10 + "record": { 11 11 + "type": "object", 12 12 + "required": ["createdAt"], 13 13 + "properties": { 14 14 + "createdAt": { 15 15 + "type": "string", 16 16 + "format": "datetime" 17 17 + } 18 18 + } 19 19 + } 20 20 + } 21 21 + } 22 22 + }