+208 -128

api/atproto/cbor_gen.go

reviewed

··· 129 129 return fmt.Errorf("RepoStrongRef: map struct too large (%d)", extra) 130 130 } 131 131 132 132 - var name string 133 132 n := extra 134 133 134 134 + nameBuf := make([]byte, 5) 135 135 for i := uint64(0); i < n; i++ { 136 136 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 137 137 + if err != nil { 138 138 + return err 139 139 + } 136 140 137 137 - { 138 138 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 139 139 - if err != nil { 141 141 + if !ok { 142 142 + // Field doesn't exist on this type, so ignore it 143 143 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 140 144 return err 141 145 } 142 142 - 143 143 - name = string(sval) 146 146 + continue 144 147 } 145 148 146 146 - switch name { 149 149 + switch string(nameBuf[:nameLen]) { 147 150 // t.Cid (string) (string) 148 151 case "cid": 149 152 ··· 180 183 181 184 default: 182 185 // Field doesn't exist on this type, so ignore it 183 183 - cbg.ScanForLinks(r, func(cid.Cid) {}) 186 186 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 187 187 + return err 188 188 + } 184 189 } 185 190 } 186 191 ··· 492 497 return fmt.Errorf("SyncSubscribeRepos_Commit: map struct too large (%d)", extra) 493 498 } 494 499 495 495 - var name string 496 500 n := extra 497 501 502 502 + nameBuf := make([]byte, 6) 498 503 for i := uint64(0); i < n; i++ { 504 504 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 505 505 + if err != nil { 506 506 + return err 507 507 + } 499 508 500 500 - { 501 501 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 502 502 - if err != nil { 509 509 + if !ok { 510 510 + // Field doesn't exist on this type, so ignore it 511 511 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 503 512 return err 504 513 } 505 505 - 506 506 - name = string(sval) 514 514 + continue 507 515 } 508 516 509 509 - switch name { 517 517 + switch string(nameBuf[:nameLen]) { 510 518 // t.Ops ([]*atproto.SyncSubscribeRepos_RepoOp) (slice) 511 519 case "ops": 512 520 ··· 767 775 768 776 default: 769 777 // Field doesn't exist on this type, so ignore it 770 770 - cbg.ScanForLinks(r, func(cid.Cid) {}) 778 778 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 779 779 + return err 780 780 + } 771 781 } 772 782 } 773 783 ··· 901 911 return fmt.Errorf("SyncSubscribeRepos_Handle: map struct too large (%d)", extra) 902 912 } 903 913 904 904 - var name string 905 914 n := extra 906 915 916 916 + nameBuf := make([]byte, 6) 907 917 for i := uint64(0); i < n; i++ { 918 918 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 919 919 + if err != nil { 920 920 + return err 921 921 + } 908 922 909 909 - { 910 910 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 911 911 - if err != nil { 923 923 + if !ok { 924 924 + // Field doesn't exist on this type, so ignore it 925 925 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 912 926 return err 913 927 } 914 914 - 915 915 - name = string(sval) 928 928 + continue 916 929 } 917 930 918 918 - switch name { 931 931 + switch string(nameBuf[:nameLen]) { 919 932 // t.Did (string) (string) 920 933 case "did": 921 934 ··· 978 991 979 992 default: 980 993 // Field doesn't exist on this type, so ignore it 981 981 - cbg.ScanForLinks(r, func(cid.Cid) {}) 994 994 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 995 995 + return err 996 996 + } 982 997 } 983 998 } 984 999 ··· 1126 1141 return fmt.Errorf("SyncSubscribeRepos_Identity: map struct too large (%d)", extra) 1127 1142 } 1128 1143 1129 1129 - var name string 1130 1144 n := extra 1131 1145 1146 1146 + nameBuf := make([]byte, 6) 1132 1147 for i := uint64(0); i < n; i++ { 1148 1148 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1149 1149 + if err != nil { 1150 1150 + return err 1151 1151 + } 1133 1152 1134 1134 - { 1135 1135 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1136 1136 - if err != nil { 1153 1153 + if !ok { 1154 1154 + // Field doesn't exist on this type, so ignore it 1155 1155 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1137 1156 return err 1138 1157 } 1139 1139 - 1140 1140 - name = string(sval) 1158 1158 + continue 1141 1159 } 1142 1160 1143 1143 - switch name { 1161 1161 + switch string(nameBuf[:nameLen]) { 1144 1162 // t.Did (string) (string) 1145 1163 case "did": 1146 1164 ··· 1213 1231 1214 1232 default: 1215 1233 // Field doesn't exist on this type, so ignore it 1216 1216 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1234 1234 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1235 1235 + return err 1236 1236 + } 1217 1237 } 1218 1238 } 1219 1239 ··· 1377 1397 return fmt.Errorf("SyncSubscribeRepos_Account: map struct too large (%d)", extra) 1378 1398 } 1379 1399 1380 1380 - var name string 1381 1400 n := extra 1382 1401 1402 1402 + nameBuf := make([]byte, 6) 1383 1403 for i := uint64(0); i < n; i++ { 1404 1404 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1405 1405 + if err != nil { 1406 1406 + return err 1407 1407 + } 1384 1408 1385 1385 - { 1386 1386 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1387 1387 - if err != nil { 1409 1409 + if !ok { 1410 1410 + // Field doesn't exist on this type, so ignore it 1411 1411 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1388 1412 return err 1389 1413 } 1390 1390 - 1391 1391 - name = string(sval) 1414 1414 + continue 1392 1415 } 1393 1416 1394 1394 - switch name { 1417 1417 + switch string(nameBuf[:nameLen]) { 1395 1418 // t.Did (string) (string) 1396 1419 case "did": 1397 1420 ··· 1482 1505 1483 1506 default: 1484 1507 // Field doesn't exist on this type, so ignore it 1485 1485 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1508 1508 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1509 1509 + return err 1510 1510 + } 1486 1511 } 1487 1512 } 1488 1513 ··· 1585 1610 return fmt.Errorf("SyncSubscribeRepos_Info: map struct too large (%d)", extra) 1586 1611 } 1587 1612 1588 1588 - var name string 1589 1613 n := extra 1590 1614 1615 1615 + nameBuf := make([]byte, 7) 1591 1616 for i := uint64(0); i < n; i++ { 1617 1617 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1618 1618 + if err != nil { 1619 1619 + return err 1620 1620 + } 1592 1621 1593 1593 - { 1594 1594 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1595 1595 - if err != nil { 1622 1622 + if !ok { 1623 1623 + // Field doesn't exist on this type, so ignore it 1624 1624 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1596 1625 return err 1597 1626 } 1598 1598 - 1599 1599 - name = string(sval) 1627 1627 + continue 1600 1628 } 1601 1629 1602 1602 - switch name { 1630 1630 + switch string(nameBuf[:nameLen]) { 1603 1631 // t.Name (string) (string) 1604 1632 case "name": 1605 1633 ··· 1635 1663 1636 1664 default: 1637 1665 // Field doesn't exist on this type, so ignore it 1638 1638 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1666 1666 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1667 1667 + return err 1668 1668 + } 1639 1669 } 1640 1670 } 1641 1671 ··· 1775 1805 return fmt.Errorf("SyncSubscribeRepos_Migrate: map struct too large (%d)", extra) 1776 1806 } 1777 1807 1778 1778 - var name string 1779 1808 n := extra 1780 1809 1810 1810 + nameBuf := make([]byte, 9) 1781 1811 for i := uint64(0); i < n; i++ { 1812 1812 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1813 1813 + if err != nil { 1814 1814 + return err 1815 1815 + } 1782 1816 1783 1783 - { 1784 1784 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1785 1785 - if err != nil { 1817 1817 + if !ok { 1818 1818 + // Field doesn't exist on this type, so ignore it 1819 1819 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1786 1820 return err 1787 1821 } 1788 1788 - 1789 1789 - name = string(sval) 1822 1822 + continue 1790 1823 } 1791 1824 1792 1792 - switch name { 1825 1825 + switch string(nameBuf[:nameLen]) { 1793 1826 // t.Did (string) (string) 1794 1827 case "did": 1795 1828 ··· 1862 1895 1863 1896 default: 1864 1897 // Field doesn't exist on this type, so ignore it 1865 1865 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1898 1898 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1899 1899 + return err 1900 1900 + } 1866 1901 } 1867 1902 } 1868 1903 ··· 1967 2002 return fmt.Errorf("SyncSubscribeRepos_RepoOp: map struct too large (%d)", extra) 1968 2003 } 1969 2004 1970 1970 - var name string 1971 2005 n := extra 1972 2006 2007 2007 + nameBuf := make([]byte, 6) 1973 2008 for i := uint64(0); i < n; i++ { 2009 2009 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2010 2010 + if err != nil { 2011 2011 + return err 2012 2012 + } 1974 2013 1975 1975 - { 1976 1976 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1977 1977 - if err != nil { 2014 2014 + if !ok { 2015 2015 + // Field doesn't exist on this type, so ignore it 2016 2016 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1978 2017 return err 1979 2018 } 1980 1980 - 1981 1981 - name = string(sval) 2019 2019 + continue 1982 2020 } 1983 2021 1984 1984 - switch name { 2022 2022 + switch string(nameBuf[:nameLen]) { 1985 2023 // t.Cid (util.LexLink) (struct) 1986 2024 case "cid": 1987 2025 ··· 2027 2065 2028 2066 default: 2029 2067 // Field doesn't exist on this type, so ignore it 2030 2030 - cbg.ScanForLinks(r, func(cid.Cid) {}) 2068 2068 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2069 2069 + return err 2070 2070 + } 2031 2071 } 2032 2072 } 2033 2073 ··· 2138 2178 return fmt.Errorf("SyncSubscribeRepos_Tombstone: map struct too large (%d)", extra) 2139 2179 } 2140 2180 2141 2141 - var name string 2142 2181 n := extra 2143 2182 2183 2183 + nameBuf := make([]byte, 4) 2144 2184 for i := uint64(0); i < n; i++ { 2185 2185 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2186 2186 + if err != nil { 2187 2187 + return err 2188 2188 + } 2145 2189 2146 2146 - { 2147 2147 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2148 2148 - if err != nil { 2190 2190 + if !ok { 2191 2191 + // Field doesn't exist on this type, so ignore it 2192 2192 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2149 2193 return err 2150 2194 } 2151 2151 - 2152 2152 - name = string(sval) 2195 2195 + continue 2153 2196 } 2154 2197 2155 2155 - switch name { 2198 2198 + switch string(nameBuf[:nameLen]) { 2156 2199 // t.Did (string) (string) 2157 2200 case "did": 2158 2201 ··· 2204 2247 2205 2248 default: 2206 2249 // Field doesn't exist on this type, so ignore it 2207 2207 - cbg.ScanForLinks(r, func(cid.Cid) {}) 2250 2250 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2251 2251 + return err 2252 2252 + } 2208 2253 } 2209 2254 } 2210 2255 ··· 2301 2346 return fmt.Errorf("LabelDefs_SelfLabels: map struct too large (%d)", extra) 2302 2347 } 2303 2348 2304 2304 - var name string 2305 2349 n := extra 2306 2350 2351 2351 + nameBuf := make([]byte, 6) 2307 2352 for i := uint64(0); i < n; i++ { 2353 2353 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2354 2354 + if err != nil { 2355 2355 + return err 2356 2356 + } 2308 2357 2309 2309 - { 2310 2310 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2311 2311 - if err != nil { 2358 2358 + if !ok { 2359 2359 + // Field doesn't exist on this type, so ignore it 2360 2360 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2312 2361 return err 2313 2362 } 2314 2314 - 2315 2315 - name = string(sval) 2363 2363 + continue 2316 2364 } 2317 2365 2318 2318 - switch name { 2366 2366 + switch string(nameBuf[:nameLen]) { 2319 2367 // t.LexiconTypeID (string) (string) 2320 2368 case "$type": 2321 2369 ··· 2390 2438 2391 2439 default: 2392 2440 // Field doesn't exist on this type, so ignore it 2393 2393 - cbg.ScanForLinks(r, func(cid.Cid) {}) 2441 2441 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2442 2442 + return err 2443 2443 + } 2394 2444 } 2395 2445 } 2396 2446 ··· 2456 2506 return fmt.Errorf("LabelDefs_SelfLabel: map struct too large (%d)", extra) 2457 2507 } 2458 2508 2459 2459 - var name string 2460 2509 n := extra 2461 2510 2511 2511 + nameBuf := make([]byte, 3) 2462 2512 for i := uint64(0); i < n; i++ { 2513 2513 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2514 2514 + if err != nil { 2515 2515 + return err 2516 2516 + } 2463 2517 2464 2464 - { 2465 2465 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2466 2466 - if err != nil { 2518 2518 + if !ok { 2519 2519 + // Field doesn't exist on this type, so ignore it 2520 2520 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2467 2521 return err 2468 2522 } 2469 2469 - 2470 2470 - name = string(sval) 2523 2523 + continue 2471 2524 } 2472 2525 2473 2473 - switch name { 2526 2526 + switch string(nameBuf[:nameLen]) { 2474 2527 // t.Val (string) (string) 2475 2528 case "val": 2476 2529 ··· 2485 2538 2486 2539 default: 2487 2540 // Field doesn't exist on this type, so ignore it 2488 2488 - cbg.ScanForLinks(r, func(cid.Cid) {}) 2541 2541 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2542 2542 + return err 2543 2543 + } 2489 2544 } 2490 2545 } 2491 2546 ··· 2790 2845 return fmt.Errorf("LabelDefs_Label: map struct too large (%d)", extra) 2791 2846 } 2792 2847 2793 2793 - var name string 2794 2848 n := extra 2795 2849 2850 2850 + nameBuf := make([]byte, 3) 2796 2851 for i := uint64(0); i < n; i++ { 2852 2852 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2853 2853 + if err != nil { 2854 2854 + return err 2855 2855 + } 2797 2856 2798 2798 - { 2799 2799 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2800 2800 - if err != nil { 2857 2857 + if !ok { 2858 2858 + // Field doesn't exist on this type, so ignore it 2859 2859 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2801 2860 return err 2802 2861 } 2803 2803 - 2804 2804 - name = string(sval) 2862 2862 + continue 2805 2863 } 2806 2864 2807 2807 - switch name { 2865 2865 + switch string(nameBuf[:nameLen]) { 2808 2866 // t.Cid (string) (string) 2809 2867 case "cid": 2810 2868 ··· 2986 3044 2987 3045 default: 2988 3046 // Field doesn't exist on this type, so ignore it 2989 2989 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3047 3047 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3048 3048 + return err 3049 3049 + } 2990 3050 } 2991 3051 } 2992 3052 ··· 3077 3137 return fmt.Errorf("LabelSubscribeLabels_Labels: map struct too large (%d)", extra) 3078 3138 } 3079 3139 3080 3080 - var name string 3081 3140 n := extra 3082 3141 3142 3142 + nameBuf := make([]byte, 6) 3083 3143 for i := uint64(0); i < n; i++ { 3144 3144 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3145 3145 + if err != nil { 3146 3146 + return err 3147 3147 + } 3084 3148 3085 3085 - { 3086 3086 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3087 3087 - if err != nil { 3149 3149 + if !ok { 3150 3150 + // Field doesn't exist on this type, so ignore it 3151 3151 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3088 3152 return err 3089 3153 } 3090 3090 - 3091 3091 - name = string(sval) 3154 3154 + continue 3092 3155 } 3093 3156 3094 3094 - switch name { 3157 3157 + switch string(nameBuf[:nameLen]) { 3095 3158 // t.Seq (int64) (int64) 3096 3159 case "seq": 3097 3160 { ··· 3170 3233 3171 3234 default: 3172 3235 // Field doesn't exist on this type, so ignore it 3173 3173 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3236 3236 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3237 3237 + return err 3238 3238 + } 3174 3239 } 3175 3240 } 3176 3241 ··· 3273 3338 return fmt.Errorf("LabelSubscribeLabels_Info: map struct too large (%d)", extra) 3274 3339 } 3275 3340 3276 3276 - var name string 3277 3341 n := extra 3278 3342 3343 3343 + nameBuf := make([]byte, 7) 3279 3344 for i := uint64(0); i < n; i++ { 3345 3345 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3346 3346 + if err != nil { 3347 3347 + return err 3348 3348 + } 3280 3349 3281 3281 - { 3282 3282 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3283 3283 - if err != nil { 3350 3350 + if !ok { 3351 3351 + // Field doesn't exist on this type, so ignore it 3352 3352 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3284 3353 return err 3285 3354 } 3286 3286 - 3287 3287 - name = string(sval) 3355 3355 + continue 3288 3356 } 3289 3357 3290 3290 - switch name { 3358 3358 + switch string(nameBuf[:nameLen]) { 3291 3359 // t.Name (string) (string) 3292 3360 case "name": 3293 3361 ··· 3323 3391 3324 3392 default: 3325 3393 // Field doesn't exist on this type, so ignore it 3326 3326 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3394 3394 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3395 3395 + return err 3396 3396 + } 3327 3397 } 3328 3398 } 3329 3399 ··· 3527 3597 return fmt.Errorf("LabelDefs_LabelValueDefinition: map struct too large (%d)", extra) 3528 3598 } 3529 3599 3530 3530 - var name string 3531 3600 n := extra 3532 3601 3602 3602 + nameBuf := make([]byte, 14) 3533 3603 for i := uint64(0); i < n; i++ { 3604 3604 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3605 3605 + if err != nil { 3606 3606 + return err 3607 3607 + } 3534 3608 3535 3535 - { 3536 3536 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3537 3537 - if err != nil { 3609 3609 + if !ok { 3610 3610 + // Field doesn't exist on this type, so ignore it 3611 3611 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3538 3612 return err 3539 3613 } 3540 3540 - 3541 3541 - name = string(sval) 3614 3614 + continue 3542 3615 } 3543 3616 3544 3544 - switch name { 3617 3617 + switch string(nameBuf[:nameLen]) { 3545 3618 // t.Blurs (string) (string) 3546 3619 case "blurs": 3547 3620 ··· 3681 3754 3682 3755 default: 3683 3756 // Field doesn't exist on this type, so ignore it 3684 3684 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3757 3757 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3758 3758 + return err 3759 3759 + } 3685 3760 } 3686 3761 } 3687 3762 ··· 3793 3868 return fmt.Errorf("LabelDefs_LabelValueDefinitionStrings: map struct too large (%d)", extra) 3794 3869 } 3795 3870 3796 3796 - var name string 3797 3871 n := extra 3798 3872 3873 3873 + nameBuf := make([]byte, 11) 3799 3874 for i := uint64(0); i < n; i++ { 3875 3875 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3876 3876 + if err != nil { 3877 3877 + return err 3878 3878 + } 3800 3879 3801 3801 - { 3802 3802 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3803 3803 - if err != nil { 3880 3880 + if !ok { 3881 3881 + // Field doesn't exist on this type, so ignore it 3882 3882 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3804 3883 return err 3805 3884 } 3806 3806 - 3807 3807 - name = string(sval) 3885 3885 + continue 3808 3886 } 3809 3887 3810 3810 - switch name { 3888 3888 + switch string(nameBuf[:nameLen]) { 3811 3889 // t.Lang (string) (string) 3812 3890 case "lang": 3813 3891 ··· 3844 3922 3845 3923 default: 3846 3924 // Field doesn't exist on this type, so ignore it 3847 3847 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3925 3925 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3926 3926 + return err 3927 3927 + } 3848 3928 } 3849 3929 } 3850 3930

+494 -304

api/bsky/cbor_gen.go

reviewed

··· 338 338 return fmt.Errorf("FeedPost: map struct too large (%d)", extra) 339 339 } 340 340 341 341 - var name string 342 341 n := extra 343 342 343 343 + nameBuf := make([]byte, 9) 344 344 for i := uint64(0); i < n; i++ { 345 345 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 346 346 + if err != nil { 347 347 + return err 348 348 + } 345 349 346 346 - { 347 347 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 348 348 - if err != nil { 350 350 + if !ok { 351 351 + // Field doesn't exist on this type, so ignore it 352 352 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 349 353 return err 350 354 } 351 351 - 352 352 - name = string(sval) 355 355 + continue 353 356 } 354 357 355 355 - switch name { 358 358 + switch string(nameBuf[:nameLen]) { 356 359 // t.Tags ([]string) (slice) 357 360 case "tags": 358 361 ··· 627 630 628 631 default: 629 632 // Field doesn't exist on this type, so ignore it 630 630 - cbg.ScanForLinks(r, func(cid.Cid) {}) 633 633 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 634 634 + return err 635 635 + } 631 636 } 632 637 } 633 638 ··· 728 733 return fmt.Errorf("FeedRepost: map struct too large (%d)", extra) 729 734 } 730 735 731 731 - var name string 732 736 n := extra 733 737 738 738 + nameBuf := make([]byte, 9) 734 739 for i := uint64(0); i < n; i++ { 740 740 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 741 741 + if err != nil { 742 742 + return err 743 743 + } 735 744 736 736 - { 737 737 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 738 738 - if err != nil { 745 745 + if !ok { 746 746 + // Field doesn't exist on this type, so ignore it 747 747 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 739 748 return err 740 749 } 741 741 - 742 742 - name = string(sval) 750 750 + continue 743 751 } 744 752 745 745 - switch name { 753 753 + switch string(nameBuf[:nameLen]) { 746 754 // t.LexiconTypeID (string) (string) 747 755 case "$type": 748 756 ··· 788 796 789 797 default: 790 798 // Field doesn't exist on this type, so ignore it 791 791 - cbg.ScanForLinks(r, func(cid.Cid) {}) 799 799 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 800 800 + return err 801 801 + } 792 802 } 793 803 } 794 804 ··· 893 903 return fmt.Errorf("FeedPost_Entity: map struct too large (%d)", extra) 894 904 } 895 905 896 896 - var name string 897 906 n := extra 898 907 908 908 + nameBuf := make([]byte, 5) 899 909 for i := uint64(0); i < n; i++ { 910 910 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 911 911 + if err != nil { 912 912 + return err 913 913 + } 900 914 901 901 - { 902 902 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 903 903 - if err != nil { 915 915 + if !ok { 916 916 + // Field doesn't exist on this type, so ignore it 917 917 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 904 918 return err 905 919 } 906 906 - 907 907 - name = string(sval) 920 920 + continue 908 921 } 909 922 910 910 - switch name { 923 923 + switch string(nameBuf[:nameLen]) { 911 924 // t.Type (string) (string) 912 925 case "type": 913 926 ··· 953 966 954 967 default: 955 968 // Field doesn't exist on this type, so ignore it 956 956 - cbg.ScanForLinks(r, func(cid.Cid) {}) 969 969 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 970 970 + return err 971 971 + } 957 972 } 958 973 } 959 974 ··· 1028 1043 return fmt.Errorf("FeedPost_ReplyRef: map struct too large (%d)", extra) 1029 1044 } 1030 1045 1031 1031 - var name string 1032 1046 n := extra 1033 1047 1048 1048 + nameBuf := make([]byte, 6) 1034 1049 for i := uint64(0); i < n; i++ { 1050 1050 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1051 1051 + if err != nil { 1052 1052 + return err 1053 1053 + } 1035 1054 1036 1036 - { 1037 1037 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1038 1038 - if err != nil { 1055 1055 + if !ok { 1056 1056 + // Field doesn't exist on this type, so ignore it 1057 1057 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1039 1058 return err 1040 1059 } 1041 1041 - 1042 1042 - name = string(sval) 1060 1060 + continue 1043 1061 } 1044 1062 1045 1045 - switch name { 1063 1063 + switch string(nameBuf[:nameLen]) { 1046 1064 // t.Root (atproto.RepoStrongRef) (struct) 1047 1065 case "root": 1048 1066 ··· 1086 1104 1087 1105 default: 1088 1106 // Field doesn't exist on this type, so ignore it 1089 1089 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1107 1107 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1108 1108 + return err 1109 1109 + } 1090 1110 } 1091 1111 } 1092 1112 ··· 1174 1194 return fmt.Errorf("FeedPost_TextSlice: map struct too large (%d)", extra) 1175 1195 } 1176 1196 1177 1177 - var name string 1178 1197 n := extra 1179 1198 1199 1199 + nameBuf := make([]byte, 5) 1180 1200 for i := uint64(0); i < n; i++ { 1201 1201 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1202 1202 + if err != nil { 1203 1203 + return err 1204 1204 + } 1181 1205 1182 1182 - { 1183 1183 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1184 1184 - if err != nil { 1206 1206 + if !ok { 1207 1207 + // Field doesn't exist on this type, so ignore it 1208 1208 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1185 1209 return err 1186 1210 } 1187 1187 - 1188 1188 - name = string(sval) 1211 1211 + continue 1189 1212 } 1190 1213 1191 1191 - switch name { 1214 1214 + switch string(nameBuf[:nameLen]) { 1192 1215 // t.End (int64) (int64) 1193 1216 case "end": 1194 1217 { ··· 1244 1267 1245 1268 default: 1246 1269 // Field doesn't exist on this type, so ignore it 1247 1247 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1270 1270 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1271 1271 + return err 1272 1272 + } 1248 1273 } 1249 1274 } 1250 1275 ··· 1332 1357 return fmt.Errorf("EmbedImages: map struct too large (%d)", extra) 1333 1358 } 1334 1359 1335 1335 - var name string 1336 1360 n := extra 1337 1361 1362 1362 + nameBuf := make([]byte, 6) 1338 1363 for i := uint64(0); i < n; i++ { 1364 1364 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1365 1365 + if err != nil { 1366 1366 + return err 1367 1367 + } 1339 1368 1340 1340 - { 1341 1341 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1342 1342 - if err != nil { 1369 1369 + if !ok { 1370 1370 + // Field doesn't exist on this type, so ignore it 1371 1371 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1343 1372 return err 1344 1373 } 1345 1345 - 1346 1346 - name = string(sval) 1374 1374 + continue 1347 1375 } 1348 1376 1349 1349 - switch name { 1377 1377 + switch string(nameBuf[:nameLen]) { 1350 1378 // t.LexiconTypeID (string) (string) 1351 1379 case "$type": 1352 1380 ··· 1410 1438 1411 1439 default: 1412 1440 // Field doesn't exist on this type, so ignore it 1413 1413 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1441 1441 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1442 1442 + return err 1443 1443 + } 1414 1444 } 1415 1445 } 1416 1446 ··· 1488 1518 return fmt.Errorf("EmbedExternal: map struct too large (%d)", extra) 1489 1519 } 1490 1520 1491 1491 - var name string 1492 1521 n := extra 1493 1522 1523 1523 + nameBuf := make([]byte, 8) 1494 1524 for i := uint64(0); i < n; i++ { 1525 1525 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1526 1526 + if err != nil { 1527 1527 + return err 1528 1528 + } 1495 1529 1496 1496 - { 1497 1497 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1498 1498 - if err != nil { 1530 1530 + if !ok { 1531 1531 + // Field doesn't exist on this type, so ignore it 1532 1532 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1499 1533 return err 1500 1534 } 1501 1501 - 1502 1502 - name = string(sval) 1535 1535 + continue 1503 1536 } 1504 1537 1505 1505 - switch name { 1538 1538 + switch string(nameBuf[:nameLen]) { 1506 1539 // t.LexiconTypeID (string) (string) 1507 1540 case "$type": 1508 1541 ··· 1537 1570 1538 1571 default: 1539 1572 // Field doesn't exist on this type, so ignore it 1540 1540 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1573 1573 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1574 1574 + return err 1575 1575 + } 1541 1576 } 1542 1577 } 1543 1578 ··· 1673 1708 return fmt.Errorf("EmbedExternal_External: map struct too large (%d)", extra) 1674 1709 } 1675 1710 1676 1676 - var name string 1677 1711 n := extra 1678 1712 1713 1713 + nameBuf := make([]byte, 11) 1679 1714 for i := uint64(0); i < n; i++ { 1715 1715 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1716 1716 + if err != nil { 1717 1717 + return err 1718 1718 + } 1680 1719 1681 1681 - { 1682 1682 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1683 1683 - if err != nil { 1720 1720 + if !ok { 1721 1721 + // Field doesn't exist on this type, so ignore it 1722 1722 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1684 1723 return err 1685 1724 } 1686 1686 - 1687 1687 - name = string(sval) 1725 1725 + continue 1688 1726 } 1689 1727 1690 1690 - switch name { 1728 1728 + switch string(nameBuf[:nameLen]) { 1691 1729 // t.Uri (string) (string) 1692 1730 case "uri": 1693 1731 ··· 1744 1782 1745 1783 default: 1746 1784 // Field doesn't exist on this type, so ignore it 1747 1747 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1785 1785 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1786 1786 + return err 1787 1787 + } 1748 1788 } 1749 1789 } 1750 1790 ··· 1850 1890 return fmt.Errorf("EmbedImages_Image: map struct too large (%d)", extra) 1851 1891 } 1852 1892 1853 1853 - var name string 1854 1893 n := extra 1855 1894 1895 1895 + nameBuf := make([]byte, 11) 1856 1896 for i := uint64(0); i < n; i++ { 1897 1897 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1898 1898 + if err != nil { 1899 1899 + return err 1900 1900 + } 1857 1901 1858 1858 - { 1859 1859 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1860 1860 - if err != nil { 1902 1902 + if !ok { 1903 1903 + // Field doesn't exist on this type, so ignore it 1904 1904 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1861 1905 return err 1862 1906 } 1863 1863 - 1864 1864 - name = string(sval) 1907 1907 + continue 1865 1908 } 1866 1909 1867 1867 - switch name { 1910 1910 + switch string(nameBuf[:nameLen]) { 1868 1911 // t.Alt (string) (string) 1869 1912 case "alt": 1870 1913 ··· 1919 1962 1920 1963 default: 1921 1964 // Field doesn't exist on this type, so ignore it 1922 1922 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1965 1965 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1966 1966 + return err 1967 1967 + } 1923 1968 } 1924 1969 } 1925 1970 ··· 2027 2072 return fmt.Errorf("GraphFollow: map struct too large (%d)", extra) 2028 2073 } 2029 2074 2030 2030 - var name string 2031 2075 n := extra 2032 2076 2077 2077 + nameBuf := make([]byte, 9) 2033 2078 for i := uint64(0); i < n; i++ { 2079 2079 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2080 2080 + if err != nil { 2081 2081 + return err 2082 2082 + } 2034 2083 2035 2035 - { 2036 2036 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2037 2037 - if err != nil { 2084 2084 + if !ok { 2085 2085 + // Field doesn't exist on this type, so ignore it 2086 2086 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2038 2087 return err 2039 2088 } 2040 2040 - 2041 2041 - name = string(sval) 2089 2089 + continue 2042 2090 } 2043 2091 2044 2044 - switch name { 2092 2092 + switch string(nameBuf[:nameLen]) { 2045 2093 // t.LexiconTypeID (string) (string) 2046 2094 case "$type": 2047 2095 ··· 2078 2126 2079 2127 default: 2080 2128 // Field doesn't exist on this type, so ignore it 2081 2081 - cbg.ScanForLinks(r, func(cid.Cid) {}) 2129 2129 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2130 2130 + return err 2131 2131 + } 2082 2132 } 2083 2133 } 2084 2134 ··· 2364 2414 return fmt.Errorf("ActorProfile: map struct too large (%d)", extra) 2365 2415 } 2366 2416 2367 2367 - var name string 2368 2417 n := extra 2369 2418 2419 2419 + nameBuf := make([]byte, 20) 2370 2420 for i := uint64(0); i < n; i++ { 2421 2421 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2422 2422 + if err != nil { 2423 2423 + return err 2424 2424 + } 2371 2425 2372 2372 - { 2373 2373 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2374 2374 - if err != nil { 2426 2426 + if !ok { 2427 2427 + // Field doesn't exist on this type, so ignore it 2428 2428 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2375 2429 return err 2376 2430 } 2377 2377 - 2378 2378 - name = string(sval) 2431 2431 + continue 2379 2432 } 2380 2433 2381 2381 - switch name { 2434 2434 + switch string(nameBuf[:nameLen]) { 2382 2435 // t.LexiconTypeID (string) (string) 2383 2436 case "$type": 2384 2437 ··· 2556 2609 2557 2610 default: 2558 2611 // Field doesn't exist on this type, so ignore it 2559 2559 - cbg.ScanForLinks(r, func(cid.Cid) {}) 2612 2612 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2613 2613 + return err 2614 2614 + } 2560 2615 } 2561 2616 } 2562 2617 ··· 2634 2689 return fmt.Errorf("EmbedRecord: map struct too large (%d)", extra) 2635 2690 } 2636 2691 2637 2637 - var name string 2638 2692 n := extra 2639 2693 2694 2694 + nameBuf := make([]byte, 6) 2640 2695 for i := uint64(0); i < n; i++ { 2696 2696 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2697 2697 + if err != nil { 2698 2698 + return err 2699 2699 + } 2641 2700 2642 2642 - { 2643 2643 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2644 2644 - if err != nil { 2701 2701 + if !ok { 2702 2702 + // Field doesn't exist on this type, so ignore it 2703 2703 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2645 2704 return err 2646 2705 } 2647 2647 - 2648 2648 - name = string(sval) 2706 2706 + continue 2649 2707 } 2650 2708 2651 2651 - switch name { 2709 2709 + switch string(nameBuf[:nameLen]) { 2652 2710 // t.LexiconTypeID (string) (string) 2653 2711 case "$type": 2654 2712 ··· 2683 2741 2684 2742 default: 2685 2743 // Field doesn't exist on this type, so ignore it 2686 2686 - cbg.ScanForLinks(r, func(cid.Cid) {}) 2744 2744 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2745 2745 + return err 2746 2746 + } 2687 2747 } 2688 2748 } 2689 2749 ··· 2784 2844 return fmt.Errorf("FeedLike: map struct too large (%d)", extra) 2785 2845 } 2786 2846 2787 2787 - var name string 2788 2847 n := extra 2789 2848 2849 2849 + nameBuf := make([]byte, 9) 2790 2850 for i := uint64(0); i < n; i++ { 2851 2851 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2852 2852 + if err != nil { 2853 2853 + return err 2854 2854 + } 2791 2855 2792 2792 - { 2793 2793 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2794 2794 - if err != nil { 2856 2856 + if !ok { 2857 2857 + // Field doesn't exist on this type, so ignore it 2858 2858 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2795 2859 return err 2796 2860 } 2797 2797 - 2798 2798 - name = string(sval) 2861 2861 + continue 2799 2862 } 2800 2863 2801 2801 - switch name { 2864 2864 + switch string(nameBuf[:nameLen]) { 2802 2865 // t.LexiconTypeID (string) (string) 2803 2866 case "$type": 2804 2867 ··· 2844 2907 2845 2908 default: 2846 2909 // Field doesn't exist on this type, so ignore it 2847 2847 - cbg.ScanForLinks(r, func(cid.Cid) {}) 2910 2910 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2911 2911 + return err 2912 2912 + } 2848 2913 } 2849 2914 } 2850 2915 ··· 2929 2994 return fmt.Errorf("RichtextFacet: map struct too large (%d)", extra) 2930 2995 } 2931 2996 2932 2932 - var name string 2933 2997 n := extra 2934 2998 2999 2999 + nameBuf := make([]byte, 8) 2935 3000 for i := uint64(0); i < n; i++ { 3001 3001 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3002 3002 + if err != nil { 3003 3003 + return err 3004 3004 + } 2936 3005 2937 2937 - { 2938 2938 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2939 2939 - if err != nil { 3006 3006 + if !ok { 3007 3007 + // Field doesn't exist on this type, so ignore it 3008 3008 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2940 3009 return err 2941 3010 } 2942 2942 - 2943 2943 - name = string(sval) 3011 3011 + continue 2944 3012 } 2945 3013 2946 2946 - switch name { 3014 3014 + switch string(nameBuf[:nameLen]) { 2947 3015 // t.Index (bsky.RichtextFacet_ByteSlice) (struct) 2948 3016 case "index": 2949 3017 ··· 3016 3084 3017 3085 default: 3018 3086 // Field doesn't exist on this type, so ignore it 3019 3019 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3087 3087 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3088 3088 + return err 3089 3089 + } 3020 3090 } 3021 3091 } 3022 3092 ··· 3104 3174 return fmt.Errorf("RichtextFacet_ByteSlice: map struct too large (%d)", extra) 3105 3175 } 3106 3176 3107 3107 - var name string 3108 3177 n := extra 3109 3178 3179 3179 + nameBuf := make([]byte, 9) 3110 3180 for i := uint64(0); i < n; i++ { 3181 3181 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3182 3182 + if err != nil { 3183 3183 + return err 3184 3184 + } 3111 3185 3112 3112 - { 3113 3113 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3114 3114 - if err != nil { 3186 3186 + if !ok { 3187 3187 + // Field doesn't exist on this type, so ignore it 3188 3188 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3115 3189 return err 3116 3190 } 3117 3117 - 3118 3118 - name = string(sval) 3191 3191 + continue 3119 3192 } 3120 3193 3121 3121 - switch name { 3194 3194 + switch string(nameBuf[:nameLen]) { 3122 3195 // t.ByteEnd (int64) (int64) 3123 3196 case "byteEnd": 3124 3197 { ··· 3174 3247 3175 3248 default: 3176 3249 // Field doesn't exist on this type, so ignore it 3177 3177 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3250 3250 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3251 3251 + return err 3252 3252 + } 3178 3253 } 3179 3254 } 3180 3255 ··· 3259 3334 return fmt.Errorf("RichtextFacet_Link: map struct too large (%d)", extra) 3260 3335 } 3261 3336 3262 3262 - var name string 3263 3337 n := extra 3264 3338 3339 3339 + nameBuf := make([]byte, 5) 3265 3340 for i := uint64(0); i < n; i++ { 3341 3341 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3342 3342 + if err != nil { 3343 3343 + return err 3344 3344 + } 3266 3345 3267 3267 - { 3268 3268 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3269 3269 - if err != nil { 3346 3346 + if !ok { 3347 3347 + // Field doesn't exist on this type, so ignore it 3348 3348 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3270 3349 return err 3271 3350 } 3272 3272 - 3273 3273 - name = string(sval) 3351 3351 + continue 3274 3352 } 3275 3353 3276 3276 - switch name { 3354 3354 + switch string(nameBuf[:nameLen]) { 3277 3355 // t.Uri (string) (string) 3278 3356 case "uri": 3279 3357 ··· 3299 3377 3300 3378 default: 3301 3379 // Field doesn't exist on this type, so ignore it 3302 3302 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3380 3380 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3381 3381 + return err 3382 3382 + } 3303 3383 } 3304 3384 } 3305 3385 ··· 3384 3464 return fmt.Errorf("RichtextFacet_Mention: map struct too large (%d)", extra) 3385 3465 } 3386 3466 3387 3387 - var name string 3388 3467 n := extra 3389 3468 3469 3469 + nameBuf := make([]byte, 5) 3390 3470 for i := uint64(0); i < n; i++ { 3471 3471 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3472 3472 + if err != nil { 3473 3473 + return err 3474 3474 + } 3391 3475 3392 3392 - { 3393 3393 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3394 3394 - if err != nil { 3476 3476 + if !ok { 3477 3477 + // Field doesn't exist on this type, so ignore it 3478 3478 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3395 3479 return err 3396 3480 } 3397 3397 - 3398 3398 - name = string(sval) 3481 3481 + continue 3399 3482 } 3400 3483 3401 3401 - switch name { 3484 3484 + switch string(nameBuf[:nameLen]) { 3402 3485 // t.Did (string) (string) 3403 3486 case "did": 3404 3487 ··· 3424 3507 3425 3508 default: 3426 3509 // Field doesn't exist on this type, so ignore it 3427 3427 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3510 3510 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3511 3511 + return err 3512 3512 + } 3428 3513 } 3429 3514 } 3430 3515 ··· 3509 3594 return fmt.Errorf("RichtextFacet_Tag: map struct too large (%d)", extra) 3510 3595 } 3511 3596 3512 3512 - var name string 3513 3597 n := extra 3514 3598 3599 3599 + nameBuf := make([]byte, 5) 3515 3600 for i := uint64(0); i < n; i++ { 3601 3601 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3602 3602 + if err != nil { 3603 3603 + return err 3604 3604 + } 3516 3605 3517 3517 - { 3518 3518 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3519 3519 - if err != nil { 3606 3606 + if !ok { 3607 3607 + // Field doesn't exist on this type, so ignore it 3608 3608 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3520 3609 return err 3521 3610 } 3522 3522 - 3523 3523 - name = string(sval) 3611 3611 + continue 3524 3612 } 3525 3613 3526 3526 - switch name { 3614 3614 + switch string(nameBuf[:nameLen]) { 3527 3615 // t.Tag (string) (string) 3528 3616 case "tag": 3529 3617 ··· 3549 3637 3550 3638 default: 3551 3639 // Field doesn't exist on this type, so ignore it 3552 3552 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3640 3640 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3641 3641 + return err 3642 3642 + } 3553 3643 } 3554 3644 } 3555 3645 ··· 3643 3733 return fmt.Errorf("EmbedRecordWithMedia: map struct too large (%d)", extra) 3644 3734 } 3645 3735 3646 3646 - var name string 3647 3736 n := extra 3648 3737 3738 3738 + nameBuf := make([]byte, 6) 3649 3739 for i := uint64(0); i < n; i++ { 3740 3740 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3741 3741 + if err != nil { 3742 3742 + return err 3743 3743 + } 3650 3744 3651 3651 - { 3652 3652 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3653 3653 - if err != nil { 3745 3745 + if !ok { 3746 3746 + // Field doesn't exist on this type, so ignore it 3747 3747 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3654 3748 return err 3655 3749 } 3656 3656 - 3657 3657 - name = string(sval) 3750 3750 + continue 3658 3751 } 3659 3752 3660 3660 - switch name { 3753 3753 + switch string(nameBuf[:nameLen]) { 3661 3754 // t.LexiconTypeID (string) (string) 3662 3755 case "$type": 3663 3756 ··· 3712 3805 3713 3806 default: 3714 3807 // Field doesn't exist on this type, so ignore it 3715 3715 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3808 3808 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3809 3809 + return err 3810 3810 + } 3716 3811 } 3717 3812 } 3718 3813 ··· 3813 3908 return fmt.Errorf("FeedDefs_NotFoundPost: map struct too large (%d)", extra) 3814 3909 } 3815 3910 3816 3816 - var name string 3817 3911 n := extra 3818 3912 3913 3913 + nameBuf := make([]byte, 8) 3819 3914 for i := uint64(0); i < n; i++ { 3915 3915 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3916 3916 + if err != nil { 3917 3917 + return err 3918 3918 + } 3820 3919 3821 3821 - { 3822 3822 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3823 3823 - if err != nil { 3920 3920 + if !ok { 3921 3921 + // Field doesn't exist on this type, so ignore it 3922 3922 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3824 3923 return err 3825 3924 } 3826 3826 - 3827 3827 - name = string(sval) 3925 3925 + continue 3828 3926 } 3829 3927 3830 3830 - switch name { 3928 3928 + switch string(nameBuf[:nameLen]) { 3831 3929 // t.Uri (string) (string) 3832 3930 case "uri": 3833 3931 ··· 3871 3969 3872 3970 default: 3873 3971 // Field doesn't exist on this type, so ignore it 3874 3874 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3972 3972 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3973 3973 + return err 3974 3974 + } 3875 3975 } 3876 3976 } 3877 3977 ··· 3979 4079 return fmt.Errorf("GraphBlock: map struct too large (%d)", extra) 3980 4080 } 3981 4081 3982 3982 - var name string 3983 4082 n := extra 3984 4083 4084 4084 + nameBuf := make([]byte, 9) 3985 4085 for i := uint64(0); i < n; i++ { 4086 4086 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 4087 4087 + if err != nil { 4088 4088 + return err 4089 4089 + } 3986 4090 3987 3987 - { 3988 3988 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3989 3989 - if err != nil { 4091 4091 + if !ok { 4092 4092 + // Field doesn't exist on this type, so ignore it 4093 4093 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3990 4094 return err 3991 4095 } 3992 3992 - 3993 3993 - name = string(sval) 4096 4096 + continue 3994 4097 } 3995 4098 3996 3996 - switch name { 4099 4099 + switch string(nameBuf[:nameLen]) { 3997 4100 // t.LexiconTypeID (string) (string) 3998 4101 case "$type": 3999 4102 ··· 4030 4133 4031 4134 default: 4032 4135 // Field doesn't exist on this type, so ignore it 4033 4033 - cbg.ScanForLinks(r, func(cid.Cid) {}) 4136 4136 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 4137 4137 + return err 4138 4138 + } 4034 4139 } 4035 4140 } 4036 4141 ··· 4283 4388 return fmt.Errorf("GraphList: map struct too large (%d)", extra) 4284 4389 } 4285 4390 4286 4286 - var name string 4287 4391 n := extra 4288 4392 4393 4393 + nameBuf := make([]byte, 17) 4289 4394 for i := uint64(0); i < n; i++ { 4395 4395 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 4396 4396 + if err != nil { 4397 4397 + return err 4398 4398 + } 4290 4399 4291 4291 - { 4292 4292 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 4293 4293 - if err != nil { 4400 4400 + if !ok { 4401 4401 + // Field doesn't exist on this type, so ignore it 4402 4402 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 4294 4403 return err 4295 4404 } 4296 4296 - 4297 4297 - name = string(sval) 4405 4405 + continue 4298 4406 } 4299 4407 4300 4300 - switch name { 4408 4408 + switch string(nameBuf[:nameLen]) { 4301 4409 // t.Name (string) (string) 4302 4410 case "name": 4303 4411 ··· 4465 4573 4466 4574 default: 4467 4575 // Field doesn't exist on this type, so ignore it 4468 4468 - cbg.ScanForLinks(r, func(cid.Cid) {}) 4576 4576 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 4577 4577 + return err 4578 4578 + } 4469 4579 } 4470 4580 } 4471 4581 ··· 4596 4706 return fmt.Errorf("GraphListitem: map struct too large (%d)", extra) 4597 4707 } 4598 4708 4599 4599 - var name string 4600 4709 n := extra 4601 4710 4711 4711 + nameBuf := make([]byte, 9) 4602 4712 for i := uint64(0); i < n; i++ { 4713 4713 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 4714 4714 + if err != nil { 4715 4715 + return err 4716 4716 + } 4603 4717 4604 4604 - { 4605 4605 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 4606 4606 - if err != nil { 4718 4718 + if !ok { 4719 4719 + // Field doesn't exist on this type, so ignore it 4720 4720 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 4607 4721 return err 4608 4722 } 4609 4609 - 4610 4610 - name = string(sval) 4723 4723 + continue 4611 4724 } 4612 4725 4613 4613 - switch name { 4726 4726 + switch string(nameBuf[:nameLen]) { 4614 4727 // t.List (string) (string) 4615 4728 case "list": 4616 4729 ··· 4658 4771 4659 4772 default: 4660 4773 // Field doesn't exist on this type, so ignore it 4661 4661 - cbg.ScanForLinks(r, func(cid.Cid) {}) 4774 4774 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 4775 4775 + return err 4776 4776 + } 4662 4777 } 4663 4778 } 4664 4779 ··· 4934 5049 return fmt.Errorf("FeedGenerator: map struct too large (%d)", extra) 4935 5050 } 4936 5051 4937 4937 - var name string 4938 5052 n := extra 4939 5053 5054 5054 + nameBuf := make([]byte, 19) 4940 5055 for i := uint64(0); i < n; i++ { 5056 5056 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 5057 5057 + if err != nil { 5058 5058 + return err 5059 5059 + } 4941 5060 4942 4942 - { 4943 4943 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 4944 4944 - if err != nil { 5061 5061 + if !ok { 5062 5062 + // Field doesn't exist on this type, so ignore it 5063 5063 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 4945 5064 return err 4946 5065 } 4947 4947 - 4948 4948 - name = string(sval) 5066 5066 + continue 4949 5067 } 4950 5068 4951 4951 - switch name { 5069 5069 + switch string(nameBuf[:nameLen]) { 4952 5070 // t.Did (string) (string) 4953 5071 case "did": 4954 5072 ··· 5139 5257 5140 5258 default: 5141 5259 // Field doesn't exist on this type, so ignore it 5142 5142 - cbg.ScanForLinks(r, func(cid.Cid) {}) 5260 5260 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 5261 5261 + return err 5262 5262 + } 5143 5263 } 5144 5264 } 5145 5265 ··· 5247 5367 return fmt.Errorf("GraphListblock: map struct too large (%d)", extra) 5248 5368 } 5249 5369 5250 5250 - var name string 5251 5370 n := extra 5252 5371 5372 5372 + nameBuf := make([]byte, 9) 5253 5373 for i := uint64(0); i < n; i++ { 5374 5374 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 5375 5375 + if err != nil { 5376 5376 + return err 5377 5377 + } 5254 5378 5255 5255 - { 5256 5256 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5257 5257 - if err != nil { 5379 5379 + if !ok { 5380 5380 + // Field doesn't exist on this type, so ignore it 5381 5381 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 5258 5382 return err 5259 5383 } 5260 5260 - 5261 5261 - name = string(sval) 5384 5384 + continue 5262 5385 } 5263 5386 5264 5264 - switch name { 5387 5387 + switch string(nameBuf[:nameLen]) { 5265 5388 // t.LexiconTypeID (string) (string) 5266 5389 case "$type": 5267 5390 ··· 5298 5421 5299 5422 default: 5300 5423 // Field doesn't exist on this type, so ignore it 5301 5301 - cbg.ScanForLinks(r, func(cid.Cid) {}) 5424 5424 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 5425 5425 + return err 5426 5426 + } 5302 5427 } 5303 5428 } 5304 5429 ··· 5386 5511 return fmt.Errorf("EmbedDefs_AspectRatio: map struct too large (%d)", extra) 5387 5512 } 5388 5513 5389 5389 - var name string 5390 5514 n := extra 5391 5515 5516 5516 + nameBuf := make([]byte, 6) 5392 5517 for i := uint64(0); i < n; i++ { 5518 5518 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 5519 5519 + if err != nil { 5520 5520 + return err 5521 5521 + } 5393 5522 5394 5394 - { 5395 5395 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5396 5396 - if err != nil { 5523 5523 + if !ok { 5524 5524 + // Field doesn't exist on this type, so ignore it 5525 5525 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 5397 5526 return err 5398 5527 } 5399 5399 - 5400 5400 - name = string(sval) 5528 5528 + continue 5401 5529 } 5402 5530 5403 5403 - switch name { 5531 5531 + switch string(nameBuf[:nameLen]) { 5404 5532 // t.Width (int64) (int64) 5405 5533 case "width": 5406 5534 { ··· 5456 5584 5457 5585 default: 5458 5586 // Field doesn't exist on this type, so ignore it 5459 5459 - cbg.ScanForLinks(r, func(cid.Cid) {}) 5587 5587 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 5588 5588 + return err 5589 5589 + } 5460 5590 } 5461 5591 } 5462 5592 ··· 5638 5768 return fmt.Errorf("FeedThreadgate: map struct too large (%d)", extra) 5639 5769 } 5640 5770 5641 5641 - var name string 5642 5771 n := extra 5643 5772 5773 5773 + nameBuf := make([]byte, 13) 5644 5774 for i := uint64(0); i < n; i++ { 5775 5775 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 5776 5776 + if err != nil { 5777 5777 + return err 5778 5778 + } 5645 5779 5646 5646 - { 5647 5647 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5648 5648 - if err != nil { 5780 5780 + if !ok { 5781 5781 + // Field doesn't exist on this type, so ignore it 5782 5782 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 5649 5783 return err 5650 5784 } 5651 5651 - 5652 5652 - name = string(sval) 5785 5785 + continue 5653 5786 } 5654 5787 5655 5655 - switch name { 5788 5788 + switch string(nameBuf[:nameLen]) { 5656 5789 // t.Post (string) (string) 5657 5790 case "post": 5658 5791 ··· 5778 5911 5779 5912 default: 5780 5913 // Field doesn't exist on this type, so ignore it 5781 5781 - cbg.ScanForLinks(r, func(cid.Cid) {}) 5914 5914 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 5915 5915 + return err 5916 5916 + } 5782 5917 } 5783 5918 } 5784 5919 ··· 5863 5998 return fmt.Errorf("FeedThreadgate_ListRule: map struct too large (%d)", extra) 5864 5999 } 5865 6000 5866 5866 - var name string 5867 6001 n := extra 5868 6002 6003 6003 + nameBuf := make([]byte, 5) 5869 6004 for i := uint64(0); i < n; i++ { 6005 6005 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6006 6006 + if err != nil { 6007 6007 + return err 6008 6008 + } 5870 6009 5871 5871 - { 5872 5872 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5873 5873 - if err != nil { 6010 6010 + if !ok { 6011 6011 + // Field doesn't exist on this type, so ignore it 6012 6012 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 5874 6013 return err 5875 6014 } 5876 5876 - 5877 5877 - name = string(sval) 6015 6015 + continue 5878 6016 } 5879 6017 5880 5880 - switch name { 6018 6018 + switch string(nameBuf[:nameLen]) { 5881 6019 // t.List (string) (string) 5882 6020 case "list": 5883 6021 ··· 5903 6041 5904 6042 default: 5905 6043 // Field doesn't exist on this type, so ignore it 5906 5906 - cbg.ScanForLinks(r, func(cid.Cid) {}) 6044 6044 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 6045 6045 + return err 6046 6046 + } 5907 6047 } 5908 6048 } 5909 6049 ··· 5965 6105 return fmt.Errorf("FeedThreadgate_MentionRule: map struct too large (%d)", extra) 5966 6106 } 5967 6107 5968 5968 - var name string 5969 6108 n := extra 5970 6109 6110 6110 + nameBuf := make([]byte, 5) 5971 6111 for i := uint64(0); i < n; i++ { 6112 6112 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6113 6113 + if err != nil { 6114 6114 + return err 6115 6115 + } 5972 6116 5973 5973 - { 5974 5974 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5975 5975 - if err != nil { 6117 6117 + if !ok { 6118 6118 + // Field doesn't exist on this type, so ignore it 6119 6119 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 5976 6120 return err 5977 6121 } 5978 5978 - 5979 5979 - name = string(sval) 6122 6122 + continue 5980 6123 } 5981 6124 5982 5982 - switch name { 6125 6125 + switch string(nameBuf[:nameLen]) { 5983 6126 // t.LexiconTypeID (string) (string) 5984 6127 case "$type": 5985 6128 ··· 5994 6137 5995 6138 default: 5996 6139 // Field doesn't exist on this type, so ignore it 5997 5997 - cbg.ScanForLinks(r, func(cid.Cid) {}) 6140 6140 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 6141 6141 + return err 6142 6142 + } 5998 6143 } 5999 6144 } 6000 6145 ··· 6056 6201 return fmt.Errorf("FeedThreadgate_FollowingRule: map struct too large (%d)", extra) 6057 6202 } 6058 6203 6059 6059 - var name string 6060 6204 n := extra 6061 6205 6206 6206 + nameBuf := make([]byte, 5) 6062 6207 for i := uint64(0); i < n; i++ { 6208 6208 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6209 6209 + if err != nil { 6210 6210 + return err 6211 6211 + } 6063 6212 6064 6064 - { 6065 6065 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6066 6066 - if err != nil { 6213 6213 + if !ok { 6214 6214 + // Field doesn't exist on this type, so ignore it 6215 6215 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 6067 6216 return err 6068 6217 } 6069 6069 - 6070 6070 - name = string(sval) 6218 6218 + continue 6071 6219 } 6072 6220 6073 6073 - switch name { 6221 6221 + switch string(nameBuf[:nameLen]) { 6074 6222 // t.LexiconTypeID (string) (string) 6075 6223 case "$type": 6076 6224 ··· 6085 6233 6086 6234 default: 6087 6235 // Field doesn't exist on this type, so ignore it 6088 6088 - cbg.ScanForLinks(r, func(cid.Cid) {}) 6236 6236 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 6237 6237 + return err 6238 6238 + } 6089 6239 } 6090 6240 } 6091 6241 ··· 6151 6301 return fmt.Errorf("GraphStarterpack_FeedItem: map struct too large (%d)", extra) 6152 6302 } 6153 6303 6154 6154 - var name string 6155 6304 n := extra 6156 6305 6306 6306 + nameBuf := make([]byte, 3) 6157 6307 for i := uint64(0); i < n; i++ { 6308 6308 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6309 6309 + if err != nil { 6310 6310 + return err 6311 6311 + } 6158 6312 6159 6159 - { 6160 6160 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6161 6161 - if err != nil { 6313 6313 + if !ok { 6314 6314 + // Field doesn't exist on this type, so ignore it 6315 6315 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 6162 6316 return err 6163 6317 } 6164 6164 - 6165 6165 - name = string(sval) 6318 6318 + continue 6166 6319 } 6167 6320 6168 6168 - switch name { 6321 6321 + switch string(nameBuf[:nameLen]) { 6169 6322 // t.Uri (string) (string) 6170 6323 case "uri": 6171 6324 ··· 6180 6333 6181 6334 default: 6182 6335 // Field doesn't exist on this type, so ignore it 6183 6183 - cbg.ScanForLinks(r, func(cid.Cid) {}) 6336 6336 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 6337 6337 + return err 6338 6338 + } 6184 6339 } 6185 6340 } 6186 6341 ··· 6414 6569 return fmt.Errorf("GraphStarterpack: map struct too large (%d)", extra) 6415 6570 } 6416 6571 6417 6417 - var name string 6418 6572 n := extra 6419 6573 6574 6574 + nameBuf := make([]byte, 17) 6420 6575 for i := uint64(0); i < n; i++ { 6576 6576 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6577 6577 + if err != nil { 6578 6578 + return err 6579 6579 + } 6421 6580 6422 6422 - { 6423 6423 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6424 6424 - if err != nil { 6581 6581 + if !ok { 6582 6582 + // Field doesn't exist on this type, so ignore it 6583 6583 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 6425 6584 return err 6426 6585 } 6427 6427 - 6428 6428 - name = string(sval) 6586 6586 + continue 6429 6587 } 6430 6588 6431 6431 - switch name { 6589 6589 + switch string(nameBuf[:nameLen]) { 6432 6590 // t.List (string) (string) 6433 6591 case "list": 6434 6592 ··· 6595 6753 6596 6754 default: 6597 6755 // Field doesn't exist on this type, so ignore it 6598 6598 - cbg.ScanForLinks(r, func(cid.Cid) {}) 6756 6756 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 6757 6757 + return err 6758 6758 + } 6599 6759 } 6600 6760 } 6601 6761 ··· 6720 6880 return fmt.Errorf("LabelerService: map struct too large (%d)", extra) 6721 6881 } 6722 6882 6723 6723 - var name string 6724 6883 n := extra 6725 6884 6885 6885 + nameBuf := make([]byte, 9) 6726 6886 for i := uint64(0); i < n; i++ { 6887 6887 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6888 6888 + if err != nil { 6889 6889 + return err 6890 6890 + } 6727 6891 6728 6728 - { 6729 6729 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6730 6730 - if err != nil { 6892 6892 + if !ok { 6893 6893 + // Field doesn't exist on this type, so ignore it 6894 6894 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 6731 6895 return err 6732 6896 } 6733 6733 - 6734 6734 - name = string(sval) 6897 6897 + continue 6735 6898 } 6736 6899 6737 6737 - switch name { 6900 6900 + switch string(nameBuf[:nameLen]) { 6738 6901 // t.LexiconTypeID (string) (string) 6739 6902 case "$type": 6740 6903 ··· 6800 6963 6801 6964 default: 6802 6965 // Field doesn't exist on this type, so ignore it 6803 6803 - cbg.ScanForLinks(r, func(cid.Cid) {}) 6966 6966 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 6967 6967 + return err 6968 6968 + } 6804 6969 } 6805 6970 } 6806 6971 ··· 6916 7081 return fmt.Errorf("LabelerDefs_LabelerPolicies: map struct too large (%d)", extra) 6917 7082 } 6918 7083 6919 6919 - var name string 6920 7084 n := extra 6921 7085 7086 7086 + nameBuf := make([]byte, 21) 6922 7087 for i := uint64(0); i < n; i++ { 7088 7088 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 7089 7089 + if err != nil { 7090 7090 + return err 7091 7091 + } 6923 7092 6924 6924 - { 6925 6925 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6926 6926 - if err != nil { 7093 7093 + if !ok { 7094 7094 + // Field doesn't exist on this type, so ignore it 7095 7095 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 6927 7096 return err 6928 7097 } 6929 6929 - 6930 6930 - name = string(sval) 7098 7098 + continue 6931 7099 } 6932 7100 6933 6933 - switch name { 7101 7101 + switch string(nameBuf[:nameLen]) { 6934 7102 // t.LabelValues ([]*string) (slice) 6935 7103 case "labelValues": 6936 7104 ··· 7033 7201 7034 7202 default: 7035 7203 // Field doesn't exist on this type, so ignore it 7036 7036 - cbg.ScanForLinks(r, func(cid.Cid) {}) 7204 7204 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 7205 7205 + return err 7206 7206 + } 7037 7207 } 7038 7208 } 7039 7209 ··· 7204 7374 return fmt.Errorf("EmbedVideo: map struct too large (%d)", extra) 7205 7375 } 7206 7376 7207 7207 - var name string 7208 7377 n := extra 7209 7378 7379 7379 + nameBuf := make([]byte, 11) 7210 7380 for i := uint64(0); i < n; i++ { 7381 7381 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 7382 7382 + if err != nil { 7383 7383 + return err 7384 7384 + } 7211 7385 7212 7212 - { 7213 7213 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 7214 7214 - if err != nil { 7386 7386 + if !ok { 7387 7387 + // Field doesn't exist on this type, so ignore it 7388 7388 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 7215 7389 return err 7216 7390 } 7217 7217 - 7218 7218 - name = string(sval) 7391 7391 + continue 7219 7392 } 7220 7393 7221 7221 - switch name { 7394 7394 + switch string(nameBuf[:nameLen]) { 7222 7395 // t.Alt (string) (string) 7223 7396 case "alt": 7224 7397 ··· 7343 7516 7344 7517 default: 7345 7518 // Field doesn't exist on this type, so ignore it 7346 7346 - cbg.ScanForLinks(r, func(cid.Cid) {}) 7519 7519 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 7520 7520 + return err 7521 7521 + } 7347 7522 } 7348 7523 } 7349 7524 ··· 7425 7600 return fmt.Errorf("EmbedVideo_Caption: map struct too large (%d)", extra) 7426 7601 } 7427 7602 7428 7428 - var name string 7429 7603 n := extra 7430 7604 7605 7605 + nameBuf := make([]byte, 4) 7431 7606 for i := uint64(0); i < n; i++ { 7607 7607 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 7608 7608 + if err != nil { 7609 7609 + return err 7610 7610 + } 7432 7611 7433 7433 - { 7434 7434 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 7435 7435 - if err != nil { 7612 7612 + if !ok { 7613 7613 + // Field doesn't exist on this type, so ignore it 7614 7614 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 7436 7615 return err 7437 7616 } 7438 7438 - 7439 7439 - name = string(sval) 7617 7617 + continue 7440 7618 } 7441 7619 7442 7442 - switch name { 7620 7620 + switch string(nameBuf[:nameLen]) { 7443 7621 // t.File (util.LexBlob) (struct) 7444 7622 case "file": 7445 7623 ··· 7474 7652 7475 7653 default: 7476 7654 // Field doesn't exist on this type, so ignore it 7477 7477 - cbg.ScanForLinks(r, func(cid.Cid) {}) 7655 7655 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 7656 7656 + return err 7657 7657 + } 7478 7658 } 7479 7659 } 7480 7660 ··· 7656 7836 return fmt.Errorf("FeedPostgate: map struct too large (%d)", extra) 7657 7837 } 7658 7838 7659 7659 - var name string 7660 7839 n := extra 7661 7840 7841 7841 + nameBuf := make([]byte, 21) 7662 7842 for i := uint64(0); i < n; i++ { 7843 7843 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 7844 7844 + if err != nil { 7845 7845 + return err 7846 7846 + } 7663 7847 7664 7664 - { 7665 7665 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 7666 7666 - if err != nil { 7848 7848 + if !ok { 7849 7849 + // Field doesn't exist on this type, so ignore it 7850 7850 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 7667 7851 return err 7668 7852 } 7669 7669 - 7670 7670 - name = string(sval) 7853 7853 + continue 7671 7854 } 7672 7855 7673 7673 - switch name { 7856 7856 + switch string(nameBuf[:nameLen]) { 7674 7857 // t.Post (string) (string) 7675 7858 case "post": 7676 7859 ··· 7796 7979 7797 7980 default: 7798 7981 // Field doesn't exist on this type, so ignore it 7799 7799 - cbg.ScanForLinks(r, func(cid.Cid) {}) 7982 7982 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 7983 7983 + return err 7984 7984 + } 7800 7985 } 7801 7986 } 7802 7987 ··· 7858 8043 return fmt.Errorf("FeedPostgate_DisableRule: map struct too large (%d)", extra) 7859 8044 } 7860 8045 7861 7861 - var name string 7862 8046 n := extra 7863 8047 8048 8048 + nameBuf := make([]byte, 5) 7864 8049 for i := uint64(0); i < n; i++ { 8050 8050 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 8051 8051 + if err != nil { 8052 8052 + return err 8053 8053 + } 7865 8054 7866 7866 - { 7867 7867 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 7868 7868 - if err != nil { 8055 8055 + if !ok { 8056 8056 + // Field doesn't exist on this type, so ignore it 8057 8057 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 7869 8058 return err 7870 8059 } 7871 7871 - 7872 7872 - name = string(sval) 8060 8060 + continue 7873 8061 } 7874 8062 7875 7875 - switch name { 8063 8063 + switch string(nameBuf[:nameLen]) { 7876 8064 // t.LexiconTypeID (string) (string) 7877 8065 case "$type": 7878 8066 ··· 7887 8075 7888 8076 default: 7889 8077 // Field doesn't exist on this type, so ignore it 7890 7890 - cbg.ScanForLinks(r, func(cid.Cid) {}) 8078 8078 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 8079 8079 + return err 8080 8080 + } 7891 8081 } 7892 8082 } 7893 8083

+13 -8

api/cbor_gen.go

reviewed

··· 230 230 return fmt.Errorf("CreateOp: map struct too large (%d)", extra) 231 231 } 232 232 233 233 - var name string 234 233 n := extra 235 234 235 235 + nameBuf := make([]byte, 11) 236 236 for i := uint64(0); i < n; i++ { 237 237 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 238 238 + if err != nil { 239 239 + return err 240 240 + } 237 241 238 238 - { 239 239 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 240 240 - if err != nil { 242 242 + if !ok { 243 243 + // Field doesn't exist on this type, so ignore it 244 244 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 241 245 return err 242 246 } 243 243 - 244 244 - name = string(sval) 247 247 + continue 245 248 } 246 249 247 247 - switch name { 250 250 + switch string(nameBuf[:nameLen]) { 248 251 // t.Sig (string) (string) 249 252 case "sig": 250 253 ··· 335 338 336 339 default: 337 340 // Field doesn't exist on this type, so ignore it 338 338 - cbg.ScanForLinks(r, func(cid.Cid) {}) 341 341 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 342 342 + return err 343 343 + } 339 344 } 340 345 } 341 346

+13 -8

api/chat/cbor_gen.go

reviewed

··· 97 97 return fmt.Errorf("ActorDeclaration: map struct too large (%d)", extra) 98 98 } 99 99 100 100 - var name string 101 100 n := extra 102 101 102 102 + nameBuf := make([]byte, 13) 103 103 for i := uint64(0); i < n; i++ { 104 104 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 105 105 + if err != nil { 106 106 + return err 107 107 + } 104 108 105 105 - { 106 106 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 107 107 - if err != nil { 109 109 + if !ok { 110 110 + // Field doesn't exist on this type, so ignore it 111 111 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 108 112 return err 109 113 } 110 110 - 111 111 - name = string(sval) 114 114 + continue 112 115 } 113 116 114 114 - switch name { 117 117 + switch string(nameBuf[:nameLen]) { 115 118 // t.LexiconTypeID (string) (string) 116 119 case "$type": 117 120 ··· 137 140 138 141 default: 139 142 // Field doesn't exist on this type, so ignore it 140 140 - cbg.ScanForLinks(r, func(cid.Cid) {}) 143 143 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 144 144 + return err 145 145 + } 141 146 } 142 147 } 143 148

+39 -24

atproto/data/cbor_gen.go

reviewed

··· 78 78 return fmt.Errorf("GenericRecord: map struct too large (%d)", extra) 79 79 } 80 80 81 81 - var name string 82 81 n := extra 83 82 83 83 + nameBuf := make([]byte, 5) 84 84 for i := uint64(0); i < n; i++ { 85 85 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 86 86 + if err != nil { 87 87 + return err 88 88 + } 85 89 86 86 - { 87 87 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 88 88 - if err != nil { 90 90 + if !ok { 91 91 + // Field doesn't exist on this type, so ignore it 92 92 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 89 93 return err 90 94 } 91 91 - 92 92 - name = string(sval) 95 95 + continue 93 96 } 94 97 95 95 - switch name { 98 98 + switch string(nameBuf[:nameLen]) { 96 99 // t.Type (string) (string) 97 100 case "$type": 98 101 ··· 107 110 108 111 default: 109 112 // Field doesn't exist on this type, so ignore it 110 110 - cbg.ScanForLinks(r, func(cid.Cid) {}) 113 113 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 114 114 + return err 115 115 + } 111 116 } 112 117 } 113 118 ··· 196 201 return fmt.Errorf("LegacyBlobSchema: map struct too large (%d)", extra) 197 202 } 198 203 199 199 - var name string 200 204 n := extra 201 205 206 206 + nameBuf := make([]byte, 8) 202 207 for i := uint64(0); i < n; i++ { 208 208 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 209 209 + if err != nil { 210 210 + return err 211 211 + } 203 212 204 204 - { 205 205 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 206 206 - if err != nil { 213 213 + if !ok { 214 214 + // Field doesn't exist on this type, so ignore it 215 215 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 207 216 return err 208 217 } 209 209 - 210 210 - name = string(sval) 218 218 + continue 211 219 } 212 220 213 213 - switch name { 221 221 + switch string(nameBuf[:nameLen]) { 214 222 // t.Cid (string) (string) 215 223 case "cid": 216 224 ··· 236 244 237 245 default: 238 246 // Field doesn't exist on this type, so ignore it 239 239 - cbg.ScanForLinks(r, func(cid.Cid) {}) 247 247 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 248 248 + return err 249 249 + } 240 250 } 241 251 } 242 252 ··· 359 369 return fmt.Errorf("BlobSchema: map struct too large (%d)", extra) 360 370 } 361 371 362 362 - var name string 363 372 n := extra 364 373 374 374 + nameBuf := make([]byte, 8) 365 375 for i := uint64(0); i < n; i++ { 376 376 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 377 377 + if err != nil { 378 378 + return err 379 379 + } 366 380 367 367 - { 368 368 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 369 369 - if err != nil { 381 381 + if !ok { 382 382 + // Field doesn't exist on this type, so ignore it 383 383 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 370 384 return err 371 385 } 372 372 - 373 373 - name = string(sval) 386 386 + continue 374 387 } 375 388 376 376 - switch name { 389 389 + switch string(nameBuf[:nameLen]) { 377 390 // t.Ref (data.CIDLink) (struct) 378 391 case "ref": 379 392 ··· 435 448 436 449 default: 437 450 // Field doesn't exist on this type, so ignore it 438 438 - cbg.ScanForLinks(r, func(cid.Cid) {}) 451 451 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 452 452 + return err 453 453 + } 439 454 } 440 455 } 441 456

+26 -16

events/cbor_gen.go

reviewed

··· 101 101 return fmt.Errorf("EventHeader: map struct too large (%d)", extra) 102 102 } 103 103 104 104 - var name string 105 104 n := extra 106 105 106 106 + nameBuf := make([]byte, 2) 107 107 for i := uint64(0); i < n; i++ { 108 108 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 109 109 + if err != nil { 110 110 + return err 111 111 + } 108 112 109 109 - { 110 110 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 111 111 - if err != nil { 113 113 + if !ok { 114 114 + // Field doesn't exist on this type, so ignore it 115 115 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 112 116 return err 113 117 } 114 114 - 115 115 - name = string(sval) 118 118 + continue 116 119 } 117 120 118 118 - switch name { 121 121 + switch string(nameBuf[:nameLen]) { 119 122 // t.MsgType (string) (string) 120 123 case "t": 121 124 ··· 156 159 157 160 default: 158 161 // Field doesn't exist on this type, so ignore it 159 159 - cbg.ScanForLinks(r, func(cid.Cid) {}) 162 162 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 163 163 + return err 164 164 + } 160 165 } 161 166 } 162 167 ··· 245 250 return fmt.Errorf("ErrorFrame: map struct too large (%d)", extra) 246 251 } 247 252 248 248 - var name string 249 253 n := extra 250 254 255 255 + nameBuf := make([]byte, 7) 251 256 for i := uint64(0); i < n; i++ { 257 257 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 258 258 + if err != nil { 259 259 + return err 260 260 + } 252 261 253 253 - { 254 254 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 255 255 - if err != nil { 262 262 + if !ok { 263 263 + // Field doesn't exist on this type, so ignore it 264 264 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 256 265 return err 257 266 } 258 258 - 259 259 - name = string(sval) 267 267 + continue 260 268 } 261 269 262 262 - switch name { 270 270 + switch string(nameBuf[:nameLen]) { 263 271 // t.Error (string) (string) 264 272 case "error": 265 273 ··· 285 293 286 294 default: 287 295 // Field doesn't exist on this type, so ignore it 288 288 - cbg.ScanForLinks(r, func(cid.Cid) {}) 296 296 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 297 297 + return err 298 298 + } 289 299 } 290 300 } 291 301

+5 -1

go.mod

reviewed

··· 14 14 github.com/flosch/pongo2/v6 v6.0.0 15 15 github.com/go-redis/cache/v9 v9.0.0 16 16 github.com/goccy/go-json v0.10.2 17 17 + github.com/gocql/gocql v1.7.0 17 18 github.com/golang-jwt/jwt v3.2.2+incompatible 18 19 github.com/gorilla/websocket v1.5.1 19 20 github.com/hashicorp/go-retryablehttp v0.7.5 ··· 53 54 github.com/samber/slog-echo v1.8.0 54 55 github.com/stretchr/testify v1.9.0 55 56 github.com/urfave/cli/v2 v2.25.7 56 56 - github.com/whyrusleeping/cbor-gen v0.1.3-0.20240904181319-8dc02b38228c 57 57 + github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e 57 58 github.com/whyrusleeping/go-did v0.0.0-20230824162731-404d1707d5d6 58 59 gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b 59 60 go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.46.1 ··· 79 80 require ( 80 81 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect 81 82 github.com/go-redis/redis v6.15.9+incompatible // indirect 83 83 + github.com/golang/snappy v0.0.3 // indirect 84 84 + github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed // indirect 82 85 github.com/hashicorp/golang-lru v1.0.2 // indirect 83 86 github.com/jackc/puddle/v2 v2.2.1 // indirect 84 87 github.com/klauspost/compress v1.17.3 // indirect ··· 91 94 github.com/whyrusleeping/cbor v0.0.0-20171005072247-63513f603b11 // indirect 92 95 go.uber.org/zap v1.26.0 // indirect 93 96 golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect 97 97 + gopkg.in/inf.v0 v0.9.1 // indirect 94 98 ) 95 99 96 100 require (

+14 -2

go.sum

reviewed

··· 71 71 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= 72 72 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= 73 73 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= 74 74 + github.com/bitly/go-hostpool v0.0.0-20171023180738-a3a6125de932 h1:mXoPYz/Ul5HYEDvkta6I8/rnYM5gSdSV2tJ6XbZuEtY= 75 75 + github.com/bitly/go-hostpool v0.0.0-20171023180738-a3a6125de932/go.mod h1:NOuUCSz6Q9T7+igc/hlvDOUdtWKryOrtFyIVABv/p7k= 76 76 + github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 h1:DDGfHa7BWjL4YnC6+E63dPcxHo2sUxDIu8g3QgEJdRY= 77 77 + github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dRnpXw/yCqJaO+ZrUyxD+3VXMFFr56k5XYrpB4= 74 78 github.com/brianvoe/gofakeit/v6 v6.25.0 h1:ZpFjktOpLZUeF8q223o0rUuXtA+m5qW5srjvVi+JkXk= 75 79 github.com/brianvoe/gofakeit/v6 v6.25.0/go.mod h1:Xj58BMSnFqcn/fAQeSK+/PLtC5kSb7FJIq4JyGa8vEs= 76 80 github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= ··· 152 156 github.com/go-yaml/yaml v2.1.0+incompatible/go.mod h1:w2MrLa16VYP0jy6N7M5kHaCkaLENm+P+Tv+MfurjSw0= 153 157 github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU= 154 158 github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= 159 159 + github.com/gocql/gocql v1.7.0 h1:O+7U7/1gSN7QTEAaMEsJc1Oq2QHXvCWoF3DFK9HDHus= 160 160 + github.com/gocql/gocql v1.7.0/go.mod h1:vnlvXyFZeLBF0Wy+RS8hrOdbn0UWsWtdg07XJnFxZ+4= 155 161 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= 156 162 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4= 157 163 github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= ··· 189 195 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= 190 196 github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= 191 197 github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= 198 198 + github.com/golang/snappy v0.0.3 h1:fHPg5GQYlCeLIPB9BZqMVR5nR9A+IM5zcgeTdjMYmLA= 199 199 + github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= 192 200 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= 193 201 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= 194 202 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= ··· 231 239 github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY= 232 240 github.com/grpc-ecosystem/grpc-gateway/v2 v2.18.1 h1:6UKoz5ujsI55KNpsJH3UwCq3T8kKbZwNZBNPuTTje8U= 233 241 github.com/grpc-ecosystem/grpc-gateway/v2 v2.18.1/go.mod h1:YvJ2f6MplWDhfxiUC3KpyTy76kYUZA4W3pTv/wdKQ9Y= 242 242 + github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed h1:5upAirOpQc1Q53c0bnx2ufif5kANL7bfZWcc6VJWJd8= 243 243 + github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed/go.mod h1:tMWxXQ9wFIaZeTI9F+hmhFiGpFmhOHzyShyFUhRm0H4= 234 244 github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ= 235 245 github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48= 236 246 github.com/hashicorp/go-hclog v0.9.2 h1:CG6TE5H9/JXsFWJCfoIVpKFIkFe6ysEuHirp4DxCsHI= ··· 616 626 github.com/warpfork/go-wish v0.0.0-20220906213052-39a1cc7a02d0/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw= 617 627 github.com/whyrusleeping/cbor v0.0.0-20171005072247-63513f603b11 h1:5HZfQkwe0mIfyDmc1Em5GqlNRzcdtlv4HTNmdpt7XH0= 618 628 github.com/whyrusleeping/cbor v0.0.0-20171005072247-63513f603b11/go.mod h1:Wlo/SzPmxVp6vXpGt/zaXhHH0fn4IxgqZc82aKg6bpQ= 619 619 - github.com/whyrusleeping/cbor-gen v0.1.3-0.20240904181319-8dc02b38228c h1:UsxJNcLPfyLyVaA4iusIrsLAqJn/xh36Qgb8emqtXzk= 620 620 - github.com/whyrusleeping/cbor-gen v0.1.3-0.20240904181319-8dc02b38228c/go.mod h1:pM99HXyEbSQHcosHc0iW7YFmwnscr+t9Te4ibko05so= 629 629 + github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e h1:28X54ciEwwUxyHn9yrZfl5ojgF4CBNLWX7LR0rvBkf4= 630 630 + github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e/go.mod h1:pM99HXyEbSQHcosHc0iW7YFmwnscr+t9Te4ibko05so= 621 631 github.com/whyrusleeping/chunker v0.0.0-20181014151217-fe64bd25879f h1:jQa4QT2UP9WYv2nzyawpKMOCl+Z/jW7djv2/J50lj9E= 622 632 github.com/whyrusleeping/chunker v0.0.0-20181014151217-fe64bd25879f/go.mod h1:p9UJB6dDgdPgMJZs7UjUOdulKyRr9fqkS+6JKAInPy8= 623 633 github.com/whyrusleeping/go-did v0.0.0-20230824162731-404d1707d5d6 h1:yJ9/LwIGIk/c0CdoavpC9RNSGSruIspSZtxG3Nnldic= ··· 1061 1071 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= 1062 1072 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= 1063 1073 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= 1074 1074 + gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc= 1075 1075 + gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= 1064 1076 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= 1065 1077 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= 1066 1078 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

+39 -24

lex/util/cbor_gen.go

reviewed

··· 78 78 return fmt.Errorf("CborChecker: map struct too large (%d)", extra) 79 79 } 80 80 81 81 - var name string 82 81 n := extra 83 82 83 83 + nameBuf := make([]byte, 5) 84 84 for i := uint64(0); i < n; i++ { 85 85 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 86 86 + if err != nil { 87 87 + return err 88 88 + } 85 89 86 86 - { 87 87 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 88 88 - if err != nil { 90 90 + if !ok { 91 91 + // Field doesn't exist on this type, so ignore it 92 92 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 89 93 return err 90 94 } 91 91 - 92 92 - name = string(sval) 95 95 + continue 93 96 } 94 97 95 95 - switch name { 98 98 + switch string(nameBuf[:nameLen]) { 96 99 // t.Type (string) (string) 97 100 case "$type": 98 101 ··· 107 110 108 111 default: 109 112 // Field doesn't exist on this type, so ignore it 110 110 - cbg.ScanForLinks(r, func(cid.Cid) {}) 113 113 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 114 114 + return err 115 115 + } 111 116 } 112 117 } 113 118 ··· 196 201 return fmt.Errorf("LegacyBlob: map struct too large (%d)", extra) 197 202 } 198 203 199 199 - var name string 200 204 n := extra 201 205 206 206 + nameBuf := make([]byte, 8) 202 207 for i := uint64(0); i < n; i++ { 208 208 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 209 209 + if err != nil { 210 210 + return err 211 211 + } 203 212 204 204 - { 205 205 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 206 206 - if err != nil { 213 213 + if !ok { 214 214 + // Field doesn't exist on this type, so ignore it 215 215 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 207 216 return err 208 217 } 209 209 - 210 210 - name = string(sval) 218 218 + continue 211 219 } 212 220 213 213 - switch name { 221 221 + switch string(nameBuf[:nameLen]) { 214 222 // t.Cid (string) (string) 215 223 case "cid": 216 224 ··· 236 244 237 245 default: 238 246 // Field doesn't exist on this type, so ignore it 239 239 - cbg.ScanForLinks(r, func(cid.Cid) {}) 247 247 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 248 248 + return err 249 249 + } 240 250 } 241 251 } 242 252 ··· 359 369 return fmt.Errorf("BlobSchema: map struct too large (%d)", extra) 360 370 } 361 371 362 362 - var name string 363 372 n := extra 364 373 374 374 + nameBuf := make([]byte, 8) 365 375 for i := uint64(0); i < n; i++ { 376 376 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 377 377 + if err != nil { 378 378 + return err 379 379 + } 366 380 367 367 - { 368 368 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 369 369 - if err != nil { 381 381 + if !ok { 382 382 + // Field doesn't exist on this type, so ignore it 383 383 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 370 384 return err 371 385 } 372 372 - 373 373 - name = string(sval) 386 386 + continue 374 387 } 375 388 376 376 - switch name { 389 389 + switch string(nameBuf[:nameLen]) { 377 390 // t.Ref (util.LexLink) (struct) 378 391 case "ref": 379 392 ··· 435 448 436 449 default: 437 450 // Field doesn't exist on this type, so ignore it 438 438 - cbg.ScanForLinks(r, func(cid.Cid) {}) 451 451 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 452 452 + return err 453 453 + } 439 454 } 440 455 } 441 456

+78 -48

lex/util/cbor_gen_test.go

reviewed

··· 254 254 return fmt.Errorf("basicSchema: map struct too large (%d)", extra) 255 255 } 256 256 257 257 - var name string 258 257 n := extra 259 258 259 259 + nameBuf := make([]byte, 7) 260 260 for i := uint64(0); i < n; i++ { 261 261 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192) 262 262 + if err != nil { 263 263 + return err 264 264 + } 261 265 262 262 - { 263 263 - sval, err := cbg.ReadStringWithMax(cr, 8192) 264 264 - if err != nil { 266 266 + if !ok { 267 267 + // Field doesn't exist on this type, so ignore it 268 268 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 265 269 return err 266 270 } 267 267 - 268 268 - name = string(sval) 271 271 + continue 269 272 } 270 273 271 271 - switch name { 274 274 + switch string(nameBuf[:nameLen]) { 272 275 // t.Bool (bool) (bool) 273 276 case "bool": 274 277 ··· 430 433 431 434 default: 432 435 // Field doesn't exist on this type, so ignore it 433 433 - cbg.ScanForLinks(r, func(cid.Cid) {}) 436 436 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 437 437 + return err 438 438 + } 434 439 } 435 440 } 436 441 ··· 567 572 return fmt.Errorf("basicSchemaInner: map struct too large (%d)", extra) 568 573 } 569 574 570 570 - var name string 571 575 n := extra 572 576 577 577 + nameBuf := make([]byte, 6) 573 578 for i := uint64(0); i < n; i++ { 579 579 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192) 580 580 + if err != nil { 581 581 + return err 582 582 + } 574 583 575 575 - { 576 576 - sval, err := cbg.ReadStringWithMax(cr, 8192) 577 577 - if err != nil { 584 584 + if !ok { 585 585 + // Field doesn't exist on this type, so ignore it 586 586 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 578 587 return err 579 588 } 580 580 - 581 581 - name = string(sval) 589 589 + continue 582 590 } 583 591 584 584 - switch name { 592 592 + switch string(nameBuf[:nameLen]) { 585 593 // t.Arr ([]string) (slice) 586 594 case "arr": 587 595 ··· 680 688 681 689 default: 682 690 // Field doesn't exist on this type, so ignore it 683 683 - cbg.ScanForLinks(r, func(cid.Cid) {}) 691 691 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 692 692 + return err 693 693 + } 684 694 } 685 695 } 686 696 ··· 779 789 return fmt.Errorf("ipldSchema: map struct too large (%d)", extra) 780 790 } 781 791 782 782 - var name string 783 792 n := extra 784 793 794 794 + nameBuf := make([]byte, 1) 785 795 for i := uint64(0); i < n; i++ { 796 796 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192) 797 797 + if err != nil { 798 798 + return err 799 799 + } 786 800 787 787 - { 788 788 - sval, err := cbg.ReadStringWithMax(cr, 8192) 789 789 - if err != nil { 801 801 + if !ok { 802 802 + // Field doesn't exist on this type, so ignore it 803 803 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 790 804 return err 791 805 } 792 792 - 793 793 - name = string(sval) 806 806 + continue 794 807 } 795 808 796 796 - switch name { 809 809 + switch string(nameBuf[:nameLen]) { 797 810 // t.A (util.LexLink) (struct) 798 811 case "a": 799 812 ··· 840 853 841 854 default: 842 855 // Field doesn't exist on this type, so ignore it 843 843 - cbg.ScanForLinks(r, func(cid.Cid) {}) 856 856 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 857 857 + return err 858 858 + } 844 859 } 845 860 } 846 861 ··· 1059 1074 return fmt.Errorf("basicOldSchema: map struct too large (%d)", extra) 1060 1075 } 1061 1076 1062 1062 - var name string 1063 1077 n := extra 1064 1078 1079 1079 + nameBuf := make([]byte, 1) 1065 1080 for i := uint64(0); i < n; i++ { 1081 1081 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192) 1082 1082 + if err != nil { 1083 1083 + return err 1084 1084 + } 1066 1085 1067 1067 - { 1068 1068 - sval, err := cbg.ReadStringWithMax(cr, 8192) 1069 1069 - if err != nil { 1086 1086 + if !ok { 1087 1087 + // Field doesn't exist on this type, so ignore it 1088 1088 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1070 1089 return err 1071 1090 } 1072 1072 - 1073 1073 - name = string(sval) 1091 1091 + continue 1074 1092 } 1075 1093 1076 1076 - switch name { 1094 1094 + switch string(nameBuf[:nameLen]) { 1077 1095 // t.A (string) (string) 1078 1096 case "a": 1079 1097 ··· 1224 1242 1225 1243 default: 1226 1244 // Field doesn't exist on this type, so ignore it 1227 1227 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1245 1245 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1246 1246 + return err 1247 1247 + } 1228 1248 } 1229 1249 } 1230 1250 ··· 1361 1381 return fmt.Errorf("basicOldSchemaInner: map struct too large (%d)", extra) 1362 1382 } 1363 1383 1364 1364 - var name string 1365 1384 n := extra 1366 1385 1386 1386 + nameBuf := make([]byte, 1) 1367 1387 for i := uint64(0); i < n; i++ { 1388 1388 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192) 1389 1389 + if err != nil { 1390 1390 + return err 1391 1391 + } 1368 1392 1369 1369 - { 1370 1370 - sval, err := cbg.ReadStringWithMax(cr, 8192) 1371 1371 - if err != nil { 1393 1393 + if !ok { 1394 1394 + // Field doesn't exist on this type, so ignore it 1395 1395 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1372 1396 return err 1373 1397 } 1374 1374 - 1375 1375 - name = string(sval) 1398 1398 + continue 1376 1399 } 1377 1400 1378 1378 - switch name { 1401 1401 + switch string(nameBuf[:nameLen]) { 1379 1402 // t.H (string) (string) 1380 1403 case "h": 1381 1404 ··· 1474 1497 1475 1498 default: 1476 1499 // Field doesn't exist on this type, so ignore it 1477 1477 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1500 1500 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1501 1501 + return err 1502 1502 + } 1478 1503 } 1479 1504 } 1480 1505 ··· 1558 1583 return fmt.Errorf("ipldOldSchema: map struct too large (%d)", extra) 1559 1584 } 1560 1585 1561 1561 - var name string 1562 1586 n := extra 1563 1587 1588 1588 + nameBuf := make([]byte, 1) 1564 1589 for i := uint64(0); i < n; i++ { 1590 1590 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192) 1591 1591 + if err != nil { 1592 1592 + return err 1593 1593 + } 1565 1594 1566 1566 - { 1567 1567 - sval, err := cbg.ReadStringWithMax(cr, 8192) 1568 1568 - if err != nil { 1595 1595 + if !ok { 1596 1596 + // Field doesn't exist on this type, so ignore it 1597 1597 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1569 1598 return err 1570 1599 } 1571 1571 - 1572 1572 - name = string(sval) 1600 1600 + continue 1573 1601 } 1574 1602 1575 1575 - switch name { 1603 1603 + switch string(nameBuf[:nameLen]) { 1576 1604 // t.A (util.LexLink) (struct) 1577 1605 case "a": 1578 1606 ··· 1608 1636 1609 1637 default: 1610 1638 // Field doesn't exist on this type, so ignore it 1611 1611 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1639 1639 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1640 1640 + return err 1641 1641 + } 1612 1642 } 1613 1643 } 1614 1644

+26 -16

mst/cbor_gen.go

reviewed

··· 104 104 return fmt.Errorf("nodeData: map struct too large (%d)", extra) 105 105 } 106 106 107 107 - var name string 108 107 n := extra 109 108 109 109 + nameBuf := make([]byte, 1) 110 110 for i := uint64(0); i < n; i++ { 111 111 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 112 112 + if err != nil { 113 113 + return err 114 114 + } 111 115 112 112 - { 113 113 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 114 114 - if err != nil { 116 116 + if !ok { 117 117 + // Field doesn't exist on this type, so ignore it 118 118 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 115 119 return err 116 120 } 117 117 - 118 118 - name = string(sval) 121 121 + continue 119 122 } 120 123 121 121 - switch name { 124 124 + switch string(nameBuf[:nameLen]) { 122 125 // t.Entries ([]mst.treeEntry) (slice) 123 126 case "e": 124 127 ··· 184 187 185 188 default: 186 189 // Field doesn't exist on this type, so ignore it 187 187 - cbg.ScanForLinks(r, func(cid.Cid) {}) 190 190 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 191 191 + return err 192 192 + } 188 193 } 189 194 } 190 195 ··· 312 317 return fmt.Errorf("treeEntry: map struct too large (%d)", extra) 313 318 } 314 319 315 315 - var name string 316 320 n := extra 317 321 322 322 + nameBuf := make([]byte, 1) 318 323 for i := uint64(0); i < n; i++ { 324 324 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 325 325 + if err != nil { 326 326 + return err 327 327 + } 319 328 320 320 - { 321 321 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 322 322 - if err != nil { 329 329 + if !ok { 330 330 + // Field doesn't exist on this type, so ignore it 331 331 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 323 332 return err 324 333 } 325 325 - 326 326 - name = string(sval) 334 334 + continue 327 335 } 328 336 329 329 - switch name { 337 337 + switch string(nameBuf[:nameLen]) { 330 338 // t.KeySuffix ([]uint8) (slice) 331 339 case "k": 332 340 ··· 415 423 416 424 default: 417 425 // Field doesn't exist on this type, so ignore it 418 418 - cbg.ScanForLinks(r, func(cid.Cid) {}) 426 426 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 427 427 + return err 428 428 + } 419 429 } 420 430 } 421 431

+26 -16

repo/cbor_gen.go

reviewed

··· 194 194 return fmt.Errorf("SignedCommit: map struct too large (%d)", extra) 195 195 } 196 196 197 197 - var name string 198 197 n := extra 199 198 199 199 + nameBuf := make([]byte, 7) 200 200 for i := uint64(0); i < n; i++ { 201 201 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 202 202 + if err != nil { 203 203 + return err 204 204 + } 201 205 202 202 - { 203 203 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 204 204 - if err != nil { 206 206 + if !ok { 207 207 + // Field doesn't exist on this type, so ignore it 208 208 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 205 209 return err 206 210 } 207 207 - 208 208 - name = string(sval) 211 211 + continue 209 212 } 210 213 211 211 - switch name { 214 214 + switch string(nameBuf[:nameLen]) { 212 215 // t.Did (string) (string) 213 216 case "did": 214 217 ··· 319 322 320 323 default: 321 324 // Field doesn't exist on this type, so ignore it 322 322 - cbg.ScanForLinks(r, func(cid.Cid) {}) 325 325 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 326 326 + return err 327 327 + } 323 328 } 324 329 } 325 330 ··· 477 482 return fmt.Errorf("UnsignedCommit: map struct too large (%d)", extra) 478 483 } 479 484 480 480 - var name string 481 485 n := extra 482 486 487 487 + nameBuf := make([]byte, 7) 483 488 for i := uint64(0); i < n; i++ { 489 489 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 490 490 + if err != nil { 491 491 + return err 492 492 + } 484 493 485 485 - { 486 486 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 487 487 - if err != nil { 494 494 + if !ok { 495 495 + // Field doesn't exist on this type, so ignore it 496 496 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 488 497 return err 489 498 } 490 490 - 491 491 - name = string(sval) 499 499 + continue 492 500 } 493 501 494 494 - switch name { 502 502 + switch string(nameBuf[:nameLen]) { 495 503 // t.Did (string) (string) 496 504 case "did": 497 505 ··· 579 587 580 588 default: 581 589 // Field doesn't exist on this type, so ignore it 582 582 - cbg.ScanForLinks(r, func(cid.Cid) {}) 590 590 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 591 591 + return err 592 592 + } 583 593 } 584 594 } 585 595

+13 -8

util/labels/cbor_gen.go

reviewed

··· 285 285 return fmt.Errorf("UnsignedLabel: map struct too large (%d)", extra) 286 286 } 287 287 288 288 - var name string 289 288 n := extra 290 289 290 290 + nameBuf := make([]byte, 3) 291 291 for i := uint64(0); i < n; i++ { 292 292 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 293 293 + if err != nil { 294 294 + return err 295 295 + } 292 296 293 293 - { 294 294 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 295 295 - if err != nil { 297 297 + if !ok { 298 298 + // Field doesn't exist on this type, so ignore it 299 299 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 296 300 return err 297 301 } 298 298 - 299 299 - name = string(sval) 302 302 + continue 300 303 } 301 304 302 302 - switch name { 305 305 + switch string(nameBuf[:nameLen]) { 303 306 // t.Cid (string) (string) 304 307 case "cid": 305 308 ··· 458 461 459 462 default: 460 463 // Field doesn't exist on this type, so ignore it 461 461 - cbg.ScanForLinks(r, func(cid.Cid) {}) 464 464 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 465 465 + return err 466 466 + } 462 467 } 463 468 } 464 469