+652

api/atproto/cbor_gen.go

reviewed

··· 1961 1961 1962 1962 return nil 1963 1963 } 1964 1964 + func (t *LabelDefs_Label) MarshalCBOR(w io.Writer) error { 1965 1965 + if t == nil { 1966 1966 + _, err := w.Write(cbg.CborNull) 1967 1967 + return err 1968 1968 + } 1969 1969 + 1970 1970 + cw := cbg.NewCborWriter(w) 1971 1971 + fieldCount := 6 1972 1972 + 1973 1973 + if t.Cid == nil { 1974 1974 + fieldCount-- 1975 1975 + } 1976 1976 + 1977 1977 + if t.Neg == nil { 1978 1978 + fieldCount-- 1979 1979 + } 1980 1980 + 1981 1981 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 1982 1982 + return err 1983 1983 + } 1984 1984 + 1985 1985 + // t.Cid (string) (string) 1986 1986 + if t.Cid != nil { 1987 1987 + 1988 1988 + if len("cid") > cbg.MaxLength { 1989 1989 + return xerrors.Errorf("Value in field \"cid\" was too long") 1990 1990 + } 1991 1991 + 1992 1992 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("cid"))); err != nil { 1993 1993 + return err 1994 1994 + } 1995 1995 + if _, err := cw.WriteString(string("cid")); err != nil { 1996 1996 + return err 1997 1997 + } 1998 1998 + 1999 1999 + if t.Cid == nil { 2000 2000 + if _, err := cw.Write(cbg.CborNull); err != nil { 2001 2001 + return err 2002 2002 + } 2003 2003 + } else { 2004 2004 + if len(*t.Cid) > cbg.MaxLength { 2005 2005 + return xerrors.Errorf("Value in field t.Cid was too long") 2006 2006 + } 2007 2007 + 2008 2008 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Cid))); err != nil { 2009 2009 + return err 2010 2010 + } 2011 2011 + if _, err := cw.WriteString(string(*t.Cid)); err != nil { 2012 2012 + return err 2013 2013 + } 2014 2014 + } 2015 2015 + } 2016 2016 + 2017 2017 + // t.Cts (string) (string) 2018 2018 + if len("cts") > cbg.MaxLength { 2019 2019 + return xerrors.Errorf("Value in field \"cts\" was too long") 2020 2020 + } 2021 2021 + 2022 2022 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("cts"))); err != nil { 2023 2023 + return err 2024 2024 + } 2025 2025 + if _, err := cw.WriteString(string("cts")); err != nil { 2026 2026 + return err 2027 2027 + } 2028 2028 + 2029 2029 + if len(t.Cts) > cbg.MaxLength { 2030 2030 + return xerrors.Errorf("Value in field t.Cts was too long") 2031 2031 + } 2032 2032 + 2033 2033 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Cts))); err != nil { 2034 2034 + return err 2035 2035 + } 2036 2036 + if _, err := cw.WriteString(string(t.Cts)); err != nil { 2037 2037 + return err 2038 2038 + } 2039 2039 + 2040 2040 + // t.Neg (bool) (bool) 2041 2041 + if t.Neg != nil { 2042 2042 + 2043 2043 + if len("neg") > cbg.MaxLength { 2044 2044 + return xerrors.Errorf("Value in field \"neg\" was too long") 2045 2045 + } 2046 2046 + 2047 2047 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("neg"))); err != nil { 2048 2048 + return err 2049 2049 + } 2050 2050 + if _, err := cw.WriteString(string("neg")); err != nil { 2051 2051 + return err 2052 2052 + } 2053 2053 + 2054 2054 + if t.Neg == nil { 2055 2055 + if _, err := cw.Write(cbg.CborNull); err != nil { 2056 2056 + return err 2057 2057 + } 2058 2058 + } else { 2059 2059 + if err := cbg.WriteBool(w, *t.Neg); err != nil { 2060 2060 + return err 2061 2061 + } 2062 2062 + } 2063 2063 + } 2064 2064 + 2065 2065 + // t.Src (string) (string) 2066 2066 + if len("src") > cbg.MaxLength { 2067 2067 + return xerrors.Errorf("Value in field \"src\" was too long") 2068 2068 + } 2069 2069 + 2070 2070 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("src"))); err != nil { 2071 2071 + return err 2072 2072 + } 2073 2073 + if _, err := cw.WriteString(string("src")); err != nil { 2074 2074 + return err 2075 2075 + } 2076 2076 + 2077 2077 + if len(t.Src) > cbg.MaxLength { 2078 2078 + return xerrors.Errorf("Value in field t.Src was too long") 2079 2079 + } 2080 2080 + 2081 2081 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Src))); err != nil { 2082 2082 + return err 2083 2083 + } 2084 2084 + if _, err := cw.WriteString(string(t.Src)); err != nil { 2085 2085 + return err 2086 2086 + } 2087 2087 + 2088 2088 + // t.Uri (string) (string) 2089 2089 + if len("uri") > cbg.MaxLength { 2090 2090 + return xerrors.Errorf("Value in field \"uri\" was too long") 2091 2091 + } 2092 2092 + 2093 2093 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("uri"))); err != nil { 2094 2094 + return err 2095 2095 + } 2096 2096 + if _, err := cw.WriteString(string("uri")); err != nil { 2097 2097 + return err 2098 2098 + } 2099 2099 + 2100 2100 + if len(t.Uri) > cbg.MaxLength { 2101 2101 + return xerrors.Errorf("Value in field t.Uri was too long") 2102 2102 + } 2103 2103 + 2104 2104 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Uri))); err != nil { 2105 2105 + return err 2106 2106 + } 2107 2107 + if _, err := cw.WriteString(string(t.Uri)); err != nil { 2108 2108 + return err 2109 2109 + } 2110 2110 + 2111 2111 + // t.Val (string) (string) 2112 2112 + if len("val") > cbg.MaxLength { 2113 2113 + return xerrors.Errorf("Value in field \"val\" was too long") 2114 2114 + } 2115 2115 + 2116 2116 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("val"))); err != nil { 2117 2117 + return err 2118 2118 + } 2119 2119 + if _, err := cw.WriteString(string("val")); err != nil { 2120 2120 + return err 2121 2121 + } 2122 2122 + 2123 2123 + if len(t.Val) > cbg.MaxLength { 2124 2124 + return xerrors.Errorf("Value in field t.Val was too long") 2125 2125 + } 2126 2126 + 2127 2127 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Val))); err != nil { 2128 2128 + return err 2129 2129 + } 2130 2130 + if _, err := cw.WriteString(string(t.Val)); err != nil { 2131 2131 + return err 2132 2132 + } 2133 2133 + return nil 2134 2134 + } 2135 2135 + 2136 2136 + func (t *LabelDefs_Label) UnmarshalCBOR(r io.Reader) (err error) { 2137 2137 + *t = LabelDefs_Label{} 2138 2138 + 2139 2139 + cr := cbg.NewCborReader(r) 2140 2140 + 2141 2141 + maj, extra, err := cr.ReadHeader() 2142 2142 + if err != nil { 2143 2143 + return err 2144 2144 + } 2145 2145 + defer func() { 2146 2146 + if err == io.EOF { 2147 2147 + err = io.ErrUnexpectedEOF 2148 2148 + } 2149 2149 + }() 2150 2150 + 2151 2151 + if maj != cbg.MajMap { 2152 2152 + return fmt.Errorf("cbor input should be of type map") 2153 2153 + } 2154 2154 + 2155 2155 + if extra > cbg.MaxLength { 2156 2156 + return fmt.Errorf("LabelDefs_Label: map struct too large (%d)", extra) 2157 2157 + } 2158 2158 + 2159 2159 + var name string 2160 2160 + n := extra 2161 2161 + 2162 2162 + for i := uint64(0); i < n; i++ { 2163 2163 + 2164 2164 + { 2165 2165 + sval, err := cbg.ReadString(cr) 2166 2166 + if err != nil { 2167 2167 + return err 2168 2168 + } 2169 2169 + 2170 2170 + name = string(sval) 2171 2171 + } 2172 2172 + 2173 2173 + switch name { 2174 2174 + // t.Cid (string) (string) 2175 2175 + case "cid": 2176 2176 + 2177 2177 + { 2178 2178 + b, err := cr.ReadByte() 2179 2179 + if err != nil { 2180 2180 + return err 2181 2181 + } 2182 2182 + if b != cbg.CborNull[0] { 2183 2183 + if err := cr.UnreadByte(); err != nil { 2184 2184 + return err 2185 2185 + } 2186 2186 + 2187 2187 + sval, err := cbg.ReadString(cr) 2188 2188 + if err != nil { 2189 2189 + return err 2190 2190 + } 2191 2191 + 2192 2192 + t.Cid = (*string)(&sval) 2193 2193 + } 2194 2194 + } 2195 2195 + // t.Cts (string) (string) 2196 2196 + case "cts": 2197 2197 + 2198 2198 + { 2199 2199 + sval, err := cbg.ReadString(cr) 2200 2200 + if err != nil { 2201 2201 + return err 2202 2202 + } 2203 2203 + 2204 2204 + t.Cts = string(sval) 2205 2205 + } 2206 2206 + // t.Neg (bool) (bool) 2207 2207 + case "neg": 2208 2208 + 2209 2209 + { 2210 2210 + b, err := cr.ReadByte() 2211 2211 + if err != nil { 2212 2212 + return err 2213 2213 + } 2214 2214 + if b != cbg.CborNull[0] { 2215 2215 + if err := cr.UnreadByte(); err != nil { 2216 2216 + return err 2217 2217 + } 2218 2218 + 2219 2219 + maj, extra, err = cr.ReadHeader() 2220 2220 + if err != nil { 2221 2221 + return err 2222 2222 + } 2223 2223 + if maj != cbg.MajOther { 2224 2224 + return fmt.Errorf("booleans must be major type 7") 2225 2225 + } 2226 2226 + 2227 2227 + var val bool 2228 2228 + switch extra { 2229 2229 + case 20: 2230 2230 + val = false 2231 2231 + case 21: 2232 2232 + val = true 2233 2233 + default: 2234 2234 + return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) 2235 2235 + } 2236 2236 + t.Neg = &val 2237 2237 + } 2238 2238 + } 2239 2239 + // t.Src (string) (string) 2240 2240 + case "src": 2241 2241 + 2242 2242 + { 2243 2243 + sval, err := cbg.ReadString(cr) 2244 2244 + if err != nil { 2245 2245 + return err 2246 2246 + } 2247 2247 + 2248 2248 + t.Src = string(sval) 2249 2249 + } 2250 2250 + // t.Uri (string) (string) 2251 2251 + case "uri": 2252 2252 + 2253 2253 + { 2254 2254 + sval, err := cbg.ReadString(cr) 2255 2255 + if err != nil { 2256 2256 + return err 2257 2257 + } 2258 2258 + 2259 2259 + t.Uri = string(sval) 2260 2260 + } 2261 2261 + // t.Val (string) (string) 2262 2262 + case "val": 2263 2263 + 2264 2264 + { 2265 2265 + sval, err := cbg.ReadString(cr) 2266 2266 + if err != nil { 2267 2267 + return err 2268 2268 + } 2269 2269 + 2270 2270 + t.Val = string(sval) 2271 2271 + } 2272 2272 + 2273 2273 + default: 2274 2274 + // Field doesn't exist on this type, so ignore it 2275 2275 + cbg.ScanForLinks(r, func(cid.Cid) {}) 2276 2276 + } 2277 2277 + } 2278 2278 + 2279 2279 + return nil 2280 2280 + } 2281 2281 + func (t *LabelSubscribeLabels_Labels) MarshalCBOR(w io.Writer) error { 2282 2282 + if t == nil { 2283 2283 + _, err := w.Write(cbg.CborNull) 2284 2284 + return err 2285 2285 + } 2286 2286 + 2287 2287 + cw := cbg.NewCborWriter(w) 2288 2288 + 2289 2289 + if _, err := cw.Write([]byte{162}); err != nil { 2290 2290 + return err 2291 2291 + } 2292 2292 + 2293 2293 + // t.Seq (int64) (int64) 2294 2294 + if len("seq") > cbg.MaxLength { 2295 2295 + return xerrors.Errorf("Value in field \"seq\" was too long") 2296 2296 + } 2297 2297 + 2298 2298 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("seq"))); err != nil { 2299 2299 + return err 2300 2300 + } 2301 2301 + if _, err := cw.WriteString(string("seq")); err != nil { 2302 2302 + return err 2303 2303 + } 2304 2304 + 2305 2305 + if t.Seq >= 0 { 2306 2306 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Seq)); err != nil { 2307 2307 + return err 2308 2308 + } 2309 2309 + } else { 2310 2310 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Seq-1)); err != nil { 2311 2311 + return err 2312 2312 + } 2313 2313 + } 2314 2314 + 2315 2315 + // t.Labels ([]*atproto.LabelDefs_Label) (slice) 2316 2316 + if len("labels") > cbg.MaxLength { 2317 2317 + return xerrors.Errorf("Value in field \"labels\" was too long") 2318 2318 + } 2319 2319 + 2320 2320 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("labels"))); err != nil { 2321 2321 + return err 2322 2322 + } 2323 2323 + if _, err := cw.WriteString(string("labels")); err != nil { 2324 2324 + return err 2325 2325 + } 2326 2326 + 2327 2327 + if len(t.Labels) > cbg.MaxLength { 2328 2328 + return xerrors.Errorf("Slice value in field t.Labels was too long") 2329 2329 + } 2330 2330 + 2331 2331 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Labels))); err != nil { 2332 2332 + return err 2333 2333 + } 2334 2334 + for _, v := range t.Labels { 2335 2335 + if err := v.MarshalCBOR(cw); err != nil { 2336 2336 + return err 2337 2337 + } 2338 2338 + } 2339 2339 + return nil 2340 2340 + } 2341 2341 + 2342 2342 + func (t *LabelSubscribeLabels_Labels) UnmarshalCBOR(r io.Reader) (err error) { 2343 2343 + *t = LabelSubscribeLabels_Labels{} 2344 2344 + 2345 2345 + cr := cbg.NewCborReader(r) 2346 2346 + 2347 2347 + maj, extra, err := cr.ReadHeader() 2348 2348 + if err != nil { 2349 2349 + return err 2350 2350 + } 2351 2351 + defer func() { 2352 2352 + if err == io.EOF { 2353 2353 + err = io.ErrUnexpectedEOF 2354 2354 + } 2355 2355 + }() 2356 2356 + 2357 2357 + if maj != cbg.MajMap { 2358 2358 + return fmt.Errorf("cbor input should be of type map") 2359 2359 + } 2360 2360 + 2361 2361 + if extra > cbg.MaxLength { 2362 2362 + return fmt.Errorf("LabelSubscribeLabels_Labels: map struct too large (%d)", extra) 2363 2363 + } 2364 2364 + 2365 2365 + var name string 2366 2366 + n := extra 2367 2367 + 2368 2368 + for i := uint64(0); i < n; i++ { 2369 2369 + 2370 2370 + { 2371 2371 + sval, err := cbg.ReadString(cr) 2372 2372 + if err != nil { 2373 2373 + return err 2374 2374 + } 2375 2375 + 2376 2376 + name = string(sval) 2377 2377 + } 2378 2378 + 2379 2379 + switch name { 2380 2380 + // t.Seq (int64) (int64) 2381 2381 + case "seq": 2382 2382 + { 2383 2383 + maj, extra, err := cr.ReadHeader() 2384 2384 + var extraI int64 2385 2385 + if err != nil { 2386 2386 + return err 2387 2387 + } 2388 2388 + switch maj { 2389 2389 + case cbg.MajUnsignedInt: 2390 2390 + extraI = int64(extra) 2391 2391 + if extraI < 0 { 2392 2392 + return fmt.Errorf("int64 positive overflow") 2393 2393 + } 2394 2394 + case cbg.MajNegativeInt: 2395 2395 + extraI = int64(extra) 2396 2396 + if extraI < 0 { 2397 2397 + return fmt.Errorf("int64 negative overflow") 2398 2398 + } 2399 2399 + extraI = -1 - extraI 2400 2400 + default: 2401 2401 + return fmt.Errorf("wrong type for int64 field: %d", maj) 2402 2402 + } 2403 2403 + 2404 2404 + t.Seq = int64(extraI) 2405 2405 + } 2406 2406 + // t.Labels ([]*atproto.LabelDefs_Label) (slice) 2407 2407 + case "labels": 2408 2408 + 2409 2409 + maj, extra, err = cr.ReadHeader() 2410 2410 + if err != nil { 2411 2411 + return err 2412 2412 + } 2413 2413 + 2414 2414 + if extra > cbg.MaxLength { 2415 2415 + return fmt.Errorf("t.Labels: array too large (%d)", extra) 2416 2416 + } 2417 2417 + 2418 2418 + if maj != cbg.MajArray { 2419 2419 + return fmt.Errorf("expected cbor array") 2420 2420 + } 2421 2421 + 2422 2422 + if extra > 0 { 2423 2423 + t.Labels = make([]*LabelDefs_Label, extra) 2424 2424 + } 2425 2425 + 2426 2426 + for i := 0; i < int(extra); i++ { 2427 2427 + { 2428 2428 + var maj byte 2429 2429 + var extra uint64 2430 2430 + var err error 2431 2431 + _ = maj 2432 2432 + _ = extra 2433 2433 + _ = err 2434 2434 + 2435 2435 + { 2436 2436 + 2437 2437 + b, err := cr.ReadByte() 2438 2438 + if err != nil { 2439 2439 + return err 2440 2440 + } 2441 2441 + if b != cbg.CborNull[0] { 2442 2442 + if err := cr.UnreadByte(); err != nil { 2443 2443 + return err 2444 2444 + } 2445 2445 + t.Labels[i] = new(LabelDefs_Label) 2446 2446 + if err := t.Labels[i].UnmarshalCBOR(cr); err != nil { 2447 2447 + return xerrors.Errorf("unmarshaling t.Labels[i] pointer: %w", err) 2448 2448 + } 2449 2449 + } 2450 2450 + 2451 2451 + } 2452 2452 + } 2453 2453 + } 2454 2454 + 2455 2455 + default: 2456 2456 + // Field doesn't exist on this type, so ignore it 2457 2457 + cbg.ScanForLinks(r, func(cid.Cid) {}) 2458 2458 + } 2459 2459 + } 2460 2460 + 2461 2461 + return nil 2462 2462 + } 2463 2463 + func (t *LabelSubscribeLabels_Info) MarshalCBOR(w io.Writer) error { 2464 2464 + if t == nil { 2465 2465 + _, err := w.Write(cbg.CborNull) 2466 2466 + return err 2467 2467 + } 2468 2468 + 2469 2469 + cw := cbg.NewCborWriter(w) 2470 2470 + fieldCount := 2 2471 2471 + 2472 2472 + if t.Message == nil { 2473 2473 + fieldCount-- 2474 2474 + } 2475 2475 + 2476 2476 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 2477 2477 + return err 2478 2478 + } 2479 2479 + 2480 2480 + // t.Name (string) (string) 2481 2481 + if len("name") > cbg.MaxLength { 2482 2482 + return xerrors.Errorf("Value in field \"name\" was too long") 2483 2483 + } 2484 2484 + 2485 2485 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 2486 2486 + return err 2487 2487 + } 2488 2488 + if _, err := cw.WriteString(string("name")); err != nil { 2489 2489 + return err 2490 2490 + } 2491 2491 + 2492 2492 + if len(t.Name) > cbg.MaxLength { 2493 2493 + return xerrors.Errorf("Value in field t.Name was too long") 2494 2494 + } 2495 2495 + 2496 2496 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 2497 2497 + return err 2498 2498 + } 2499 2499 + if _, err := cw.WriteString(string(t.Name)); err != nil { 2500 2500 + return err 2501 2501 + } 2502 2502 + 2503 2503 + // t.Message (string) (string) 2504 2504 + if t.Message != nil { 2505 2505 + 2506 2506 + if len("message") > cbg.MaxLength { 2507 2507 + return xerrors.Errorf("Value in field \"message\" was too long") 2508 2508 + } 2509 2509 + 2510 2510 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("message"))); err != nil { 2511 2511 + return err 2512 2512 + } 2513 2513 + if _, err := cw.WriteString(string("message")); err != nil { 2514 2514 + return err 2515 2515 + } 2516 2516 + 2517 2517 + if t.Message == nil { 2518 2518 + if _, err := cw.Write(cbg.CborNull); err != nil { 2519 2519 + return err 2520 2520 + } 2521 2521 + } else { 2522 2522 + if len(*t.Message) > cbg.MaxLength { 2523 2523 + return xerrors.Errorf("Value in field t.Message was too long") 2524 2524 + } 2525 2525 + 2526 2526 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Message))); err != nil { 2527 2527 + return err 2528 2528 + } 2529 2529 + if _, err := cw.WriteString(string(*t.Message)); err != nil { 2530 2530 + return err 2531 2531 + } 2532 2532 + } 2533 2533 + } 2534 2534 + return nil 2535 2535 + } 2536 2536 + 2537 2537 + func (t *LabelSubscribeLabels_Info) UnmarshalCBOR(r io.Reader) (err error) { 2538 2538 + *t = LabelSubscribeLabels_Info{} 2539 2539 + 2540 2540 + cr := cbg.NewCborReader(r) 2541 2541 + 2542 2542 + maj, extra, err := cr.ReadHeader() 2543 2543 + if err != nil { 2544 2544 + return err 2545 2545 + } 2546 2546 + defer func() { 2547 2547 + if err == io.EOF { 2548 2548 + err = io.ErrUnexpectedEOF 2549 2549 + } 2550 2550 + }() 2551 2551 + 2552 2552 + if maj != cbg.MajMap { 2553 2553 + return fmt.Errorf("cbor input should be of type map") 2554 2554 + } 2555 2555 + 2556 2556 + if extra > cbg.MaxLength { 2557 2557 + return fmt.Errorf("LabelSubscribeLabels_Info: map struct too large (%d)", extra) 2558 2558 + } 2559 2559 + 2560 2560 + var name string 2561 2561 + n := extra 2562 2562 + 2563 2563 + for i := uint64(0); i < n; i++ { 2564 2564 + 2565 2565 + { 2566 2566 + sval, err := cbg.ReadString(cr) 2567 2567 + if err != nil { 2568 2568 + return err 2569 2569 + } 2570 2570 + 2571 2571 + name = string(sval) 2572 2572 + } 2573 2573 + 2574 2574 + switch name { 2575 2575 + // t.Name (string) (string) 2576 2576 + case "name": 2577 2577 + 2578 2578 + { 2579 2579 + sval, err := cbg.ReadString(cr) 2580 2580 + if err != nil { 2581 2581 + return err 2582 2582 + } 2583 2583 + 2584 2584 + t.Name = string(sval) 2585 2585 + } 2586 2586 + // t.Message (string) (string) 2587 2587 + case "message": 2588 2588 + 2589 2589 + { 2590 2590 + b, err := cr.ReadByte() 2591 2591 + if err != nil { 2592 2592 + return err 2593 2593 + } 2594 2594 + if b != cbg.CborNull[0] { 2595 2595 + if err := cr.UnreadByte(); err != nil { 2596 2596 + return err 2597 2597 + } 2598 2598 + 2599 2599 + sval, err := cbg.ReadString(cr) 2600 2600 + if err != nil { 2601 2601 + return err 2602 2602 + } 2603 2603 + 2604 2604 + t.Message = (*string)(&sval) 2605 2605 + } 2606 2606 + } 2607 2607 + 2608 2608 + default: 2609 2609 + // Field doesn't exist on this type, so ignore it 2610 2610 + cbg.ScanForLinks(r, func(cid.Cid) {}) 2611 2611 + } 2612 2612 + } 2613 2613 + 2614 2614 + return nil 2615 2615 + }

-2

api/label/README.md

reviewed

··· 1 1 - 2 2 - NOTE: these lexicons are actually part of com.atproto.label.* and should end up under the package api/atproto. They are living here temporarily until the lexicons are formally merged upstream in the atproto repo.

-757

api/label/cbor_gen.go

reviewed

··· 1 1 - // Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT. 2 2 - 3 3 - package label 4 4 - 5 5 - import ( 6 6 - "fmt" 7 7 - "io" 8 8 - "math" 9 9 - "sort" 10 10 - 11 11 - cid "github.com/ipfs/go-cid" 12 12 - cbg "github.com/whyrusleeping/cbor-gen" 13 13 - xerrors "golang.org/x/xerrors" 14 14 - ) 15 15 - 16 16 - var _ = xerrors.Errorf 17 17 - var _ = cid.Undef 18 18 - var _ = math.E 19 19 - var _ = sort.Sort 20 20 - 21 21 - func (t *Label) MarshalCBOR(w io.Writer) error { 22 22 - if t == nil { 23 23 - _, err := w.Write(cbg.CborNull) 24 24 - return err 25 25 - } 26 26 - 27 27 - cw := cbg.NewCborWriter(w) 28 28 - fieldCount := 7 29 29 - 30 30 - if t.Cid == nil { 31 31 - fieldCount-- 32 32 - } 33 33 - 34 34 - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 35 35 - return err 36 36 - } 37 37 - 38 38 - // t.Cid (string) (string) 39 39 - if t.Cid != nil { 40 40 - 41 41 - if len("cid") > cbg.MaxLength { 42 42 - return xerrors.Errorf("Value in field \"cid\" was too long") 43 43 - } 44 44 - 45 45 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("cid"))); err != nil { 46 46 - return err 47 47 - } 48 48 - if _, err := cw.WriteString(string("cid")); err != nil { 49 49 - return err 50 50 - } 51 51 - 52 52 - if t.Cid == nil { 53 53 - if _, err := cw.Write(cbg.CborNull); err != nil { 54 54 - return err 55 55 - } 56 56 - } else { 57 57 - if len(*t.Cid) > cbg.MaxLength { 58 58 - return xerrors.Errorf("Value in field t.Cid was too long") 59 59 - } 60 60 - 61 61 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Cid))); err != nil { 62 62 - return err 63 63 - } 64 64 - if _, err := cw.WriteString(string(*t.Cid)); err != nil { 65 65 - return err 66 66 - } 67 67 - } 68 68 - } 69 69 - 70 70 - // t.Cts (string) (string) 71 71 - if len("cts") > cbg.MaxLength { 72 72 - return xerrors.Errorf("Value in field \"cts\" was too long") 73 73 - } 74 74 - 75 75 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("cts"))); err != nil { 76 76 - return err 77 77 - } 78 78 - if _, err := cw.WriteString(string("cts")); err != nil { 79 79 - return err 80 80 - } 81 81 - 82 82 - if len(t.Cts) > cbg.MaxLength { 83 83 - return xerrors.Errorf("Value in field t.Cts was too long") 84 84 - } 85 85 - 86 86 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Cts))); err != nil { 87 87 - return err 88 88 - } 89 89 - if _, err := cw.WriteString(string(t.Cts)); err != nil { 90 90 - return err 91 91 - } 92 92 - 93 93 - // t.Neg (bool) (bool) 94 94 - if len("neg") > cbg.MaxLength { 95 95 - return xerrors.Errorf("Value in field \"neg\" was too long") 96 96 - } 97 97 - 98 98 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("neg"))); err != nil { 99 99 - return err 100 100 - } 101 101 - if _, err := cw.WriteString(string("neg")); err != nil { 102 102 - return err 103 103 - } 104 104 - 105 105 - if err := cbg.WriteBool(w, t.Neg); err != nil { 106 106 - return err 107 107 - } 108 108 - 109 109 - // t.Src (string) (string) 110 110 - if len("src") > cbg.MaxLength { 111 111 - return xerrors.Errorf("Value in field \"src\" was too long") 112 112 - } 113 113 - 114 114 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("src"))); err != nil { 115 115 - return err 116 116 - } 117 117 - if _, err := cw.WriteString(string("src")); err != nil { 118 118 - return err 119 119 - } 120 120 - 121 121 - if len(t.Src) > cbg.MaxLength { 122 122 - return xerrors.Errorf("Value in field t.Src was too long") 123 123 - } 124 124 - 125 125 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Src))); err != nil { 126 126 - return err 127 127 - } 128 128 - if _, err := cw.WriteString(string(t.Src)); err != nil { 129 129 - return err 130 130 - } 131 131 - 132 132 - // t.Uri (string) (string) 133 133 - if len("uri") > cbg.MaxLength { 134 134 - return xerrors.Errorf("Value in field \"uri\" was too long") 135 135 - } 136 136 - 137 137 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("uri"))); err != nil { 138 138 - return err 139 139 - } 140 140 - if _, err := cw.WriteString(string("uri")); err != nil { 141 141 - return err 142 142 - } 143 143 - 144 144 - if len(t.Uri) > cbg.MaxLength { 145 145 - return xerrors.Errorf("Value in field t.Uri was too long") 146 146 - } 147 147 - 148 148 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Uri))); err != nil { 149 149 - return err 150 150 - } 151 151 - if _, err := cw.WriteString(string(t.Uri)); err != nil { 152 152 - return err 153 153 - } 154 154 - 155 155 - // t.Val (string) (string) 156 156 - if len("val") > cbg.MaxLength { 157 157 - return xerrors.Errorf("Value in field \"val\" was too long") 158 158 - } 159 159 - 160 160 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("val"))); err != nil { 161 161 - return err 162 162 - } 163 163 - if _, err := cw.WriteString(string("val")); err != nil { 164 164 - return err 165 165 - } 166 166 - 167 167 - if len(t.Val) > cbg.MaxLength { 168 168 - return xerrors.Errorf("Value in field t.Val was too long") 169 169 - } 170 170 - 171 171 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Val))); err != nil { 172 172 - return err 173 173 - } 174 174 - if _, err := cw.WriteString(string(t.Val)); err != nil { 175 175 - return err 176 176 - } 177 177 - 178 178 - // t.LexiconTypeID (string) (string) 179 179 - if len("$type") > cbg.MaxLength { 180 180 - return xerrors.Errorf("Value in field \"$type\" was too long") 181 181 - } 182 182 - 183 183 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 184 184 - return err 185 185 - } 186 186 - if _, err := cw.WriteString(string("$type")); err != nil { 187 187 - return err 188 188 - } 189 189 - 190 190 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("com.atproto.label.label"))); err != nil { 191 191 - return err 192 192 - } 193 193 - if _, err := cw.WriteString(string("com.atproto.label.label")); err != nil { 194 194 - return err 195 195 - } 196 196 - return nil 197 197 - } 198 198 - 199 199 - func (t *Label) UnmarshalCBOR(r io.Reader) (err error) { 200 200 - *t = Label{} 201 201 - 202 202 - cr := cbg.NewCborReader(r) 203 203 - 204 204 - maj, extra, err := cr.ReadHeader() 205 205 - if err != nil { 206 206 - return err 207 207 - } 208 208 - defer func() { 209 209 - if err == io.EOF { 210 210 - err = io.ErrUnexpectedEOF 211 211 - } 212 212 - }() 213 213 - 214 214 - if maj != cbg.MajMap { 215 215 - return fmt.Errorf("cbor input should be of type map") 216 216 - } 217 217 - 218 218 - if extra > cbg.MaxLength { 219 219 - return fmt.Errorf("Label: map struct too large (%d)", extra) 220 220 - } 221 221 - 222 222 - var name string 223 223 - n := extra 224 224 - 225 225 - for i := uint64(0); i < n; i++ { 226 226 - 227 227 - { 228 228 - sval, err := cbg.ReadString(cr) 229 229 - if err != nil { 230 230 - return err 231 231 - } 232 232 - 233 233 - name = string(sval) 234 234 - } 235 235 - 236 236 - switch name { 237 237 - // t.Cid (string) (string) 238 238 - case "cid": 239 239 - 240 240 - { 241 241 - b, err := cr.ReadByte() 242 242 - if err != nil { 243 243 - return err 244 244 - } 245 245 - if b != cbg.CborNull[0] { 246 246 - if err := cr.UnreadByte(); err != nil { 247 247 - return err 248 248 - } 249 249 - 250 250 - sval, err := cbg.ReadString(cr) 251 251 - if err != nil { 252 252 - return err 253 253 - } 254 254 - 255 255 - t.Cid = (*string)(&sval) 256 256 - } 257 257 - } 258 258 - // t.Cts (string) (string) 259 259 - case "cts": 260 260 - 261 261 - { 262 262 - sval, err := cbg.ReadString(cr) 263 263 - if err != nil { 264 264 - return err 265 265 - } 266 266 - 267 267 - t.Cts = string(sval) 268 268 - } 269 269 - // t.Neg (bool) (bool) 270 270 - case "neg": 271 271 - 272 272 - maj, extra, err = cr.ReadHeader() 273 273 - if err != nil { 274 274 - return err 275 275 - } 276 276 - if maj != cbg.MajOther { 277 277 - return fmt.Errorf("booleans must be major type 7") 278 278 - } 279 279 - switch extra { 280 280 - case 20: 281 281 - t.Neg = false 282 282 - case 21: 283 283 - t.Neg = true 284 284 - default: 285 285 - return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) 286 286 - } 287 287 - // t.Src (string) (string) 288 288 - case "src": 289 289 - 290 290 - { 291 291 - sval, err := cbg.ReadString(cr) 292 292 - if err != nil { 293 293 - return err 294 294 - } 295 295 - 296 296 - t.Src = string(sval) 297 297 - } 298 298 - // t.Uri (string) (string) 299 299 - case "uri": 300 300 - 301 301 - { 302 302 - sval, err := cbg.ReadString(cr) 303 303 - if err != nil { 304 304 - return err 305 305 - } 306 306 - 307 307 - t.Uri = string(sval) 308 308 - } 309 309 - // t.Val (string) (string) 310 310 - case "val": 311 311 - 312 312 - { 313 313 - sval, err := cbg.ReadString(cr) 314 314 - if err != nil { 315 315 - return err 316 316 - } 317 317 - 318 318 - t.Val = string(sval) 319 319 - } 320 320 - // t.LexiconTypeID (string) (string) 321 321 - case "$type": 322 322 - 323 323 - { 324 324 - sval, err := cbg.ReadString(cr) 325 325 - if err != nil { 326 326 - return err 327 327 - } 328 328 - 329 329 - t.LexiconTypeID = string(sval) 330 330 - } 331 331 - 332 332 - default: 333 333 - // Field doesn't exist on this type, so ignore it 334 334 - cbg.ScanForLinks(r, func(cid.Cid) {}) 335 335 - } 336 336 - } 337 337 - 338 338 - return nil 339 339 - } 340 340 - func (t *SubscribeLabels_Info) MarshalCBOR(w io.Writer) error { 341 341 - if t == nil { 342 342 - _, err := w.Write(cbg.CborNull) 343 343 - return err 344 344 - } 345 345 - 346 346 - cw := cbg.NewCborWriter(w) 347 347 - fieldCount := 3 348 348 - 349 349 - if t.LexiconTypeID == "" { 350 350 - fieldCount-- 351 351 - } 352 352 - 353 353 - if t.Message == nil { 354 354 - fieldCount-- 355 355 - } 356 356 - 357 357 - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 358 358 - return err 359 359 - } 360 360 - 361 361 - // t.Name (string) (string) 362 362 - if len("name") > cbg.MaxLength { 363 363 - return xerrors.Errorf("Value in field \"name\" was too long") 364 364 - } 365 365 - 366 366 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 367 367 - return err 368 368 - } 369 369 - if _, err := cw.WriteString(string("name")); err != nil { 370 370 - return err 371 371 - } 372 372 - 373 373 - if len(t.Name) > cbg.MaxLength { 374 374 - return xerrors.Errorf("Value in field t.Name was too long") 375 375 - } 376 376 - 377 377 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 378 378 - return err 379 379 - } 380 380 - if _, err := cw.WriteString(string(t.Name)); err != nil { 381 381 - return err 382 382 - } 383 383 - 384 384 - // t.LexiconTypeID (string) (string) 385 385 - if t.LexiconTypeID != "" { 386 386 - 387 387 - if len("$type") > cbg.MaxLength { 388 388 - return xerrors.Errorf("Value in field \"$type\" was too long") 389 389 - } 390 390 - 391 391 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 392 392 - return err 393 393 - } 394 394 - if _, err := cw.WriteString(string("$type")); err != nil { 395 395 - return err 396 396 - } 397 397 - 398 398 - if len(t.LexiconTypeID) > cbg.MaxLength { 399 399 - return xerrors.Errorf("Value in field t.LexiconTypeID was too long") 400 400 - } 401 401 - 402 402 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.LexiconTypeID))); err != nil { 403 403 - return err 404 404 - } 405 405 - if _, err := cw.WriteString(string(t.LexiconTypeID)); err != nil { 406 406 - return err 407 407 - } 408 408 - } 409 409 - 410 410 - // t.Message (string) (string) 411 411 - if t.Message != nil { 412 412 - 413 413 - if len("message") > cbg.MaxLength { 414 414 - return xerrors.Errorf("Value in field \"message\" was too long") 415 415 - } 416 416 - 417 417 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("message"))); err != nil { 418 418 - return err 419 419 - } 420 420 - if _, err := cw.WriteString(string("message")); err != nil { 421 421 - return err 422 422 - } 423 423 - 424 424 - if t.Message == nil { 425 425 - if _, err := cw.Write(cbg.CborNull); err != nil { 426 426 - return err 427 427 - } 428 428 - } else { 429 429 - if len(*t.Message) > cbg.MaxLength { 430 430 - return xerrors.Errorf("Value in field t.Message was too long") 431 431 - } 432 432 - 433 433 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Message))); err != nil { 434 434 - return err 435 435 - } 436 436 - if _, err := cw.WriteString(string(*t.Message)); err != nil { 437 437 - return err 438 438 - } 439 439 - } 440 440 - } 441 441 - return nil 442 442 - } 443 443 - 444 444 - func (t *SubscribeLabels_Info) UnmarshalCBOR(r io.Reader) (err error) { 445 445 - *t = SubscribeLabels_Info{} 446 446 - 447 447 - cr := cbg.NewCborReader(r) 448 448 - 449 449 - maj, extra, err := cr.ReadHeader() 450 450 - if err != nil { 451 451 - return err 452 452 - } 453 453 - defer func() { 454 454 - if err == io.EOF { 455 455 - err = io.ErrUnexpectedEOF 456 456 - } 457 457 - }() 458 458 - 459 459 - if maj != cbg.MajMap { 460 460 - return fmt.Errorf("cbor input should be of type map") 461 461 - } 462 462 - 463 463 - if extra > cbg.MaxLength { 464 464 - return fmt.Errorf("SubscribeLabels_Info: map struct too large (%d)", extra) 465 465 - } 466 466 - 467 467 - var name string 468 468 - n := extra 469 469 - 470 470 - for i := uint64(0); i < n; i++ { 471 471 - 472 472 - { 473 473 - sval, err := cbg.ReadString(cr) 474 474 - if err != nil { 475 475 - return err 476 476 - } 477 477 - 478 478 - name = string(sval) 479 479 - } 480 480 - 481 481 - switch name { 482 482 - // t.Name (string) (string) 483 483 - case "name": 484 484 - 485 485 - { 486 486 - sval, err := cbg.ReadString(cr) 487 487 - if err != nil { 488 488 - return err 489 489 - } 490 490 - 491 491 - t.Name = string(sval) 492 492 - } 493 493 - // t.LexiconTypeID (string) (string) 494 494 - case "$type": 495 495 - 496 496 - { 497 497 - sval, err := cbg.ReadString(cr) 498 498 - if err != nil { 499 499 - return err 500 500 - } 501 501 - 502 502 - t.LexiconTypeID = string(sval) 503 503 - } 504 504 - // t.Message (string) (string) 505 505 - case "message": 506 506 - 507 507 - { 508 508 - b, err := cr.ReadByte() 509 509 - if err != nil { 510 510 - return err 511 511 - } 512 512 - if b != cbg.CborNull[0] { 513 513 - if err := cr.UnreadByte(); err != nil { 514 514 - return err 515 515 - } 516 516 - 517 517 - sval, err := cbg.ReadString(cr) 518 518 - if err != nil { 519 519 - return err 520 520 - } 521 521 - 522 522 - t.Message = (*string)(&sval) 523 523 - } 524 524 - } 525 525 - 526 526 - default: 527 527 - // Field doesn't exist on this type, so ignore it 528 528 - cbg.ScanForLinks(r, func(cid.Cid) {}) 529 529 - } 530 530 - } 531 531 - 532 532 - return nil 533 533 - } 534 534 - func (t *SubscribeLabels_Labels) MarshalCBOR(w io.Writer) error { 535 535 - if t == nil { 536 536 - _, err := w.Write(cbg.CborNull) 537 537 - return err 538 538 - } 539 539 - 540 540 - cw := cbg.NewCborWriter(w) 541 541 - fieldCount := 3 542 542 - 543 543 - if t.LexiconTypeID == "" { 544 544 - fieldCount-- 545 545 - } 546 546 - 547 547 - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 548 548 - return err 549 549 - } 550 550 - 551 551 - // t.Seq (int64) (int64) 552 552 - if len("seq") > cbg.MaxLength { 553 553 - return xerrors.Errorf("Value in field \"seq\" was too long") 554 554 - } 555 555 - 556 556 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("seq"))); err != nil { 557 557 - return err 558 558 - } 559 559 - if _, err := cw.WriteString(string("seq")); err != nil { 560 560 - return err 561 561 - } 562 562 - 563 563 - if t.Seq >= 0 { 564 564 - if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Seq)); err != nil { 565 565 - return err 566 566 - } 567 567 - } else { 568 568 - if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Seq-1)); err != nil { 569 569 - return err 570 570 - } 571 571 - } 572 572 - 573 573 - // t.LexiconTypeID (string) (string) 574 574 - if t.LexiconTypeID != "" { 575 575 - 576 576 - if len("$type") > cbg.MaxLength { 577 577 - return xerrors.Errorf("Value in field \"$type\" was too long") 578 578 - } 579 579 - 580 580 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 581 581 - return err 582 582 - } 583 583 - if _, err := cw.WriteString(string("$type")); err != nil { 584 584 - return err 585 585 - } 586 586 - 587 587 - if len(t.LexiconTypeID) > cbg.MaxLength { 588 588 - return xerrors.Errorf("Value in field t.LexiconTypeID was too long") 589 589 - } 590 590 - 591 591 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.LexiconTypeID))); err != nil { 592 592 - return err 593 593 - } 594 594 - if _, err := cw.WriteString(string(t.LexiconTypeID)); err != nil { 595 595 - return err 596 596 - } 597 597 - } 598 598 - 599 599 - // t.Labels ([]*label.Label) (slice) 600 600 - if len("labels") > cbg.MaxLength { 601 601 - return xerrors.Errorf("Value in field \"labels\" was too long") 602 602 - } 603 603 - 604 604 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("labels"))); err != nil { 605 605 - return err 606 606 - } 607 607 - if _, err := cw.WriteString(string("labels")); err != nil { 608 608 - return err 609 609 - } 610 610 - 611 611 - if len(t.Labels) > cbg.MaxLength { 612 612 - return xerrors.Errorf("Slice value in field t.Labels was too long") 613 613 - } 614 614 - 615 615 - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Labels))); err != nil { 616 616 - return err 617 617 - } 618 618 - for _, v := range t.Labels { 619 619 - if err := v.MarshalCBOR(cw); err != nil { 620 620 - return err 621 621 - } 622 622 - } 623 623 - return nil 624 624 - } 625 625 - 626 626 - func (t *SubscribeLabels_Labels) UnmarshalCBOR(r io.Reader) (err error) { 627 627 - *t = SubscribeLabels_Labels{} 628 628 - 629 629 - cr := cbg.NewCborReader(r) 630 630 - 631 631 - maj, extra, err := cr.ReadHeader() 632 632 - if err != nil { 633 633 - return err 634 634 - } 635 635 - defer func() { 636 636 - if err == io.EOF { 637 637 - err = io.ErrUnexpectedEOF 638 638 - } 639 639 - }() 640 640 - 641 641 - if maj != cbg.MajMap { 642 642 - return fmt.Errorf("cbor input should be of type map") 643 643 - } 644 644 - 645 645 - if extra > cbg.MaxLength { 646 646 - return fmt.Errorf("SubscribeLabels_Labels: map struct too large (%d)", extra) 647 647 - } 648 648 - 649 649 - var name string 650 650 - n := extra 651 651 - 652 652 - for i := uint64(0); i < n; i++ { 653 653 - 654 654 - { 655 655 - sval, err := cbg.ReadString(cr) 656 656 - if err != nil { 657 657 - return err 658 658 - } 659 659 - 660 660 - name = string(sval) 661 661 - } 662 662 - 663 663 - switch name { 664 664 - // t.Seq (int64) (int64) 665 665 - case "seq": 666 666 - { 667 667 - maj, extra, err := cr.ReadHeader() 668 668 - var extraI int64 669 669 - if err != nil { 670 670 - return err 671 671 - } 672 672 - switch maj { 673 673 - case cbg.MajUnsignedInt: 674 674 - extraI = int64(extra) 675 675 - if extraI < 0 { 676 676 - return fmt.Errorf("int64 positive overflow") 677 677 - } 678 678 - case cbg.MajNegativeInt: 679 679 - extraI = int64(extra) 680 680 - if extraI < 0 { 681 681 - return fmt.Errorf("int64 negative overflow") 682 682 - } 683 683 - extraI = -1 - extraI 684 684 - default: 685 685 - return fmt.Errorf("wrong type for int64 field: %d", maj) 686 686 - } 687 687 - 688 688 - t.Seq = int64(extraI) 689 689 - } 690 690 - // t.LexiconTypeID (string) (string) 691 691 - case "$type": 692 692 - 693 693 - { 694 694 - sval, err := cbg.ReadString(cr) 695 695 - if err != nil { 696 696 - return err 697 697 - } 698 698 - 699 699 - t.LexiconTypeID = string(sval) 700 700 - } 701 701 - // t.Labels ([]*label.Label) (slice) 702 702 - case "labels": 703 703 - 704 704 - maj, extra, err = cr.ReadHeader() 705 705 - if err != nil { 706 706 - return err 707 707 - } 708 708 - 709 709 - if extra > cbg.MaxLength { 710 710 - return fmt.Errorf("t.Labels: array too large (%d)", extra) 711 711 - } 712 712 - 713 713 - if maj != cbg.MajArray { 714 714 - return fmt.Errorf("expected cbor array") 715 715 - } 716 716 - 717 717 - if extra > 0 { 718 718 - t.Labels = make([]*Label, extra) 719 719 - } 720 720 - 721 721 - for i := 0; i < int(extra); i++ { 722 722 - { 723 723 - var maj byte 724 724 - var extra uint64 725 725 - var err error 726 726 - _ = maj 727 727 - _ = extra 728 728 - _ = err 729 729 - 730 730 - { 731 731 - 732 732 - b, err := cr.ReadByte() 733 733 - if err != nil { 734 734 - return err 735 735 - } 736 736 - if b != cbg.CborNull[0] { 737 737 - if err := cr.UnreadByte(); err != nil { 738 738 - return err 739 739 - } 740 740 - t.Labels[i] = new(Label) 741 741 - if err := t.Labels[i].UnmarshalCBOR(cr); err != nil { 742 742 - return xerrors.Errorf("unmarshaling t.Labels[i] pointer: %w", err) 743 743 - } 744 744 - } 745 745 - 746 746 - } 747 747 - } 748 748 - } 749 749 - 750 750 - default: 751 751 - // Field doesn't exist on this type, so ignore it 752 752 - cbg.ScanForLinks(r, func(cid.Cid) {}) 753 753 - } 754 754 - } 755 755 - 756 756 - return nil 757 757 - }

-23

api/label/labellabel.go

reviewed

··· 1 1 - package label 2 2 - 3 3 - import ( 4 4 - "github.com/bluesky-social/indigo/lex/util" 5 5 - ) 6 6 - 7 7 - // schema: com.atproto.label.label 8 8 - 9 9 - func init() { 10 10 - util.RegisterType("com.atproto.label.label", &Label{}) 11 11 - } 12 12 - 13 13 - // RECORDTYPE: Label 14 14 - type Label struct { 15 15 - LexiconTypeID string `json:"$type,const=com.atproto.label.label" cborgen:"$type,const=com.atproto.label.label"` 16 16 - Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` 17 17 - Cts string `json:"cts" cborgen:"cts"` 18 18 - // manually setting this to 'bool' not '*bool' 19 19 - Neg bool `json:"neg" cborgen:"neg"` 20 20 - Src string `json:"src" cborgen:"src"` 21 21 - Uri string `json:"uri" cborgen:"uri"` 22 22 - Val string `json:"val" cborgen:"val"` 23 23 - }

-34

api/label/labelqueryLabels.go

reviewed

··· 1 1 - package label 2 2 - 3 3 - import ( 4 4 - "context" 5 5 - 6 6 - "github.com/bluesky-social/indigo/xrpc" 7 7 - ) 8 8 - 9 9 - // schema: com.atproto.label.queryLabels 10 10 - 11 11 - func init() { 12 12 - } 13 13 - 14 14 - type QueryLabels_Output struct { 15 15 - LexiconTypeID string `json:"$type,omitempty" cborgen:"$type,omitempty"` 16 16 - Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` 17 17 - Labels []*Label `json:"labels" cborgen:"labels"` 18 18 - } 19 19 - 20 20 - func QueryLabels(ctx context.Context, c *xrpc.Client, cursor string, limit int64, sources []string, uriPatterns []string) (*QueryLabels_Output, error) { 21 21 - var out QueryLabels_Output 22 22 - 23 23 - params := map[string]interface{}{ 24 24 - "cursor": cursor, 25 25 - "limit": limit, 26 26 - "sources": sources, 27 27 - "uriPatterns": uriPatterns, 28 28 - } 29 29 - if err := c.Do(ctx, xrpc.Query, "", "com.atproto.label.queryLabels", params, nil, &out); err != nil { 30 30 - return nil, err 31 31 - } 32 32 - 33 33 - return &out, nil 34 34 - }

-18

api/label/labelsubscribeLabels.go

reviewed

··· 1 1 - package label 2 2 - 3 3 - // schema: com.atproto.label.subscribeLabels 4 4 - 5 5 - func init() { 6 6 - } 7 7 - 8 8 - type SubscribeLabels_Info struct { 9 9 - LexiconTypeID string `json:"$type,omitempty" cborgen:"$type,omitempty"` 10 10 - Message *string `json:"message,omitempty" cborgen:"message,omitempty"` 11 11 - Name string `json:"name" cborgen:"name"` 12 12 - } 13 13 - 14 14 - type SubscribeLabels_Labels struct { 15 15 - LexiconTypeID string `json:"$type,omitempty" cborgen:"$type,omitempty"` 16 16 - Labels []*Label `json:"labels" cborgen:"labels"` 17 17 - Seq int64 `json:"seq" cborgen:"seq"` 18 18 - }

+3 -4

events/consumer.go

reviewed

··· 8 8 "time" 9 9 10 10 comatproto "github.com/bluesky-social/indigo/api/atproto" 11 11 - label "github.com/bluesky-social/indigo/api/label" 12 11 "github.com/prometheus/client_golang/prometheus" 13 12 "golang.org/x/time/rate" 14 13 ··· 21 20 RepoInfo func(evt *comatproto.SyncSubscribeRepos_Info) error 22 21 RepoMigrate func(evt *comatproto.SyncSubscribeRepos_Migrate) error 23 22 RepoTombstone func(evt *comatproto.SyncSubscribeRepos_Tombstone) error 24 24 - LabelLabels func(evt *label.SubscribeLabels_Labels) error 25 25 - LabelInfo func(evt *label.SubscribeLabels_Info) error 23 23 + LabelLabels func(evt *comatproto.LabelSubscribeLabels_Labels) error 24 24 + LabelInfo func(evt *comatproto.LabelSubscribeLabels_Info) error 26 25 Error func(evt *ErrorFrame) error 27 26 } 28 27 ··· 235 234 return err 236 235 } 237 236 case "#labebatch": 238 238 - var evt label.SubscribeLabels_Labels 237 237 + var evt comatproto.LabelSubscribeLabels_Labels 239 238 if err := evt.UnmarshalCBOR(r); err != nil { 240 239 return fmt.Errorf("reading Labels event: %w", err) 241 240 }

+2 -3

events/events.go

reviewed

··· 8 8 "time" 9 9 10 10 comatproto "github.com/bluesky-social/indigo/api/atproto" 11 11 - label "github.com/bluesky-social/indigo/api/label" 12 11 "github.com/bluesky-social/indigo/models" 13 12 "github.com/prometheus/client_golang/prometheus" 14 13 ··· 141 140 RepoInfo *comatproto.SyncSubscribeRepos_Info 142 141 RepoMigrate *comatproto.SyncSubscribeRepos_Migrate 143 142 RepoTombstone *comatproto.SyncSubscribeRepos_Tombstone 144 144 - LabelLabels *label.SubscribeLabels_Labels 145 145 - LabelInfo *label.SubscribeLabels_Info 143 143 + LabelLabels *comatproto.LabelSubscribeLabels_Labels 144 144 + LabelInfo *comatproto.LabelSubscribeLabels_Info 146 145 147 146 // some private fields for internal routing perf 148 147 PrivUid models.Uid `json:"-" cborgen:"-"`

+3 -5

gen/main.go

reviewed

··· 6 6 "github.com/bluesky-social/indigo/api" 7 7 atproto "github.com/bluesky-social/indigo/api/atproto" 8 8 bsky "github.com/bluesky-social/indigo/api/bsky" 9 9 - label "github.com/bluesky-social/indigo/api/label" 10 9 "github.com/bluesky-social/indigo/events" 11 10 lexutil "github.com/bluesky-social/indigo/lex/util" 12 11 "github.com/bluesky-social/indigo/mst" ··· 72 71 atproto.SyncSubscribeRepos_Tombstone{}, 73 72 atproto.LabelDefs_SelfLabels{}, 74 73 atproto.LabelDefs_SelfLabel{}, 74 74 + atproto.LabelDefs_Label{}, 75 75 + atproto.LabelSubscribeLabels_Labels{}, 76 76 + atproto.LabelSubscribeLabels_Info{}, 75 77 ); err != nil { 76 76 - panic(err) 77 77 - } 78 78 - 79 79 - if err := cbg.WriteMapEncodersToFile("api/label/cbor_gen.go", "label", label.Label{}, label.SubscribeLabels_Info{}, label.SubscribeLabels_Labels{}); err != nil { 80 78 panic(err) 81 79 } 82 80

+3 -3

labeler/commit.go

reviewed

··· 6 6 "strings" 7 7 "time" 8 8 9 9 - label "github.com/bluesky-social/indigo/api/label" 9 9 + comatproto "github.com/bluesky-social/indigo/api/atproto" 10 10 "github.com/bluesky-social/indigo/events" 11 11 "github.com/bluesky-social/indigo/models" 12 12 util "github.com/bluesky-social/indigo/util" ··· 15 15 ) 16 16 17 17 // Persist to database (and repo), and emit events. 18 18 - func (s *Server) CommitLabels(ctx context.Context, labels []*label.Label, negate bool) error { 18 18 + func (s *Server) CommitLabels(ctx context.Context, labels []*comatproto.LabelDefs_Label, negate bool) error { 19 19 20 20 now := time.Now() 21 21 nowStr := now.Format(util.ISO8601) ··· 61 61 if len(labels) > 0 { 62 62 log.Infof("broadcasting labels: %s", labels) 63 63 lev := events.XRPCStreamEvent{ 64 64 - LabelLabels: &label.SubscribeLabels_Labels{ 64 64 + LabelLabels: &comatproto.LabelSubscribeLabels_Labels{ 65 65 // NOTE(bnewbold): generic event handler code handles Seq field for us 66 66 Labels: labels, 67 67 },

+2 -3

labeler/helpers_test.go

reviewed

··· 13 13 "github.com/stretchr/testify/assert" 14 14 15 15 comatproto "github.com/bluesky-social/indigo/api/atproto" 16 16 - label "github.com/bluesky-social/indigo/api/label" 17 16 ) 18 17 19 18 // fetches report via getModerationReport, verifies match ··· 82 81 return out 83 82 } 84 83 85 85 - func testQueryLabels(t *testing.T, e *echo.Echo, lm *Server, params *url.Values) (*label.QueryLabels_Output, error) { 84 84 + func testQueryLabels(t *testing.T, e *echo.Echo, lm *Server, params *url.Values) (*comatproto.LabelQueryLabels_Output, error) { 86 85 87 86 req := httptest.NewRequest(http.MethodGet, "/xrpc/com.atproto.label.queryLabels?"+params.Encode(), nil) 88 87 req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON) ··· 92 91 if err != nil { 93 92 return nil, err 94 93 } 95 95 - var out label.QueryLabels_Output 94 94 + var out comatproto.LabelQueryLabels_Output 96 95 if err := json.Unmarshal([]byte(recorder.Body.String()), &out); err != nil { 97 96 t.Fatal(err) 98 97 }

+3 -4

labeler/service.go

reviewed

··· 14 14 "github.com/bluesky-social/indigo/api" 15 15 comatproto "github.com/bluesky-social/indigo/api/atproto" 16 16 appbsky "github.com/bluesky-social/indigo/api/bsky" 17 17 - label "github.com/bluesky-social/indigo/api/label" 18 17 "github.com/bluesky-social/indigo/bgs" 19 18 "github.com/bluesky-social/indigo/carstore" 20 19 "github.com/bluesky-social/indigo/events" ··· 358 357 return err 359 358 } 360 359 361 361 - labels := []*label.Label{} 360 360 + labels := []*comatproto.LabelDefs_Label{} 362 361 for _, op := range evt.RepoCommit.Ops { 363 362 uri := "at://" + evt.RepoCommit.Repo + "/" + op.Path 364 363 nsid := strings.SplitN(op.Path, "/", 2)[0] ··· 380 379 // apply labels with this pattern to the whole repo, not the record 381 380 if strings.HasPrefix(val, "repo:") { 382 381 val = strings.SplitN(val, ":", 2)[1] 383 383 - labels = append(labels, &label.Label{ 382 382 + labels = append(labels, &comatproto.LabelDefs_Label{ 384 383 Src: s.user.Did, 385 384 Uri: "at://" + evt.RepoCommit.Repo, 386 385 Val: val, ··· 388 387 //Cts 389 388 }) 390 389 } else { 391 391 - labels = append(labels, &label.Label{ 390 390 + labels = append(labels, &comatproto.LabelDefs_Label{ 392 391 Src: s.user.Did, 393 392 Uri: uri, 394 393 Cid: &cidStr,

+1 -2

labeler/xrpc_endpoints.go

reviewed

··· 5 5 "strconv" 6 6 7 7 atproto "github.com/bluesky-social/indigo/api/atproto" 8 8 - label "github.com/bluesky-social/indigo/api/label" 9 8 10 9 "github.com/carlmjohnson/versioninfo" 11 10 "github.com/labstack/echo/v4" ··· 76 75 sources := c.QueryParams()["sources"] 77 76 78 77 uriPatterns := c.QueryParams()["uriPatterns"] 79 79 - var out *label.QueryLabels_Output 78 78 + var out *atproto.LabelQueryLabels_Output 80 79 var handleErr error 81 80 // func (s *Server) handleComAtprotoLabelQueryLabels(ctx context.Context,cursor string,limit int,sources []string,uriPatterns []string) (*comatprototypes.LabelQueryLabels_Output, error) 82 81 out, handleErr = s.handleComAtprotoLabelQueryLabels(ctx, cursor, limit, sources, uriPatterns)

+5 -6

labeler/xrpc_handlers.go

reviewed

··· 7 7 "time" 8 8 9 9 atproto "github.com/bluesky-social/indigo/api/atproto" 10 10 - label "github.com/bluesky-social/indigo/api/label" 11 10 "github.com/bluesky-social/indigo/models" 12 11 "github.com/bluesky-social/indigo/util" 13 12 ··· 23 22 }, nil 24 23 } 25 24 26 26 - func (s *Server) handleComAtprotoLabelQueryLabels(ctx context.Context, cursor string, limit int, sources, uriPatterns []string) (*label.QueryLabels_Output, error) { 25 25 + func (s *Server) handleComAtprotoLabelQueryLabels(ctx context.Context, cursor string, limit int, sources, uriPatterns []string) (*atproto.LabelQueryLabels_Output, error) { 27 26 28 27 if limit <= 0 { 29 28 limit = 20 ··· 77 76 nextCursor = strconv.FormatUint(labelRows[len(labelRows)-1].ID, 10) 78 77 } 79 78 80 80 - labelObjs := []*label.Label{} 79 79 + labelObjs := []*atproto.LabelDefs_Label{} 81 80 for _, row := range labelRows { 82 81 neg := false 83 82 if row.Neg != nil && *row.Neg == true { 84 83 neg = true 85 84 } 86 86 - labelObjs = append(labelObjs, &label.Label{ 85 85 + labelObjs = append(labelObjs, &atproto.LabelDefs_Label{ 87 86 Src: row.SourceDid, 88 87 Uri: row.Uri, 89 88 Cid: row.Cid, 90 89 Val: row.Val, 91 91 - Neg: neg, 90 90 + Neg: &neg, 92 91 Cts: row.CreatedAt.Format(util.ISO8601), 93 92 }) 94 93 } 95 95 - out := label.QueryLabels_Output{ 94 94 + out := atproto.LabelQueryLabels_Output{ 96 95 Labels: labelObjs, 97 96 } 98 97 if nextCursor != "" {

+5 -3

labeler/xrpc_test.go

reviewed

··· 10 10 "testing" 11 11 12 12 comatproto "github.com/bluesky-social/indigo/api/atproto" 13 13 - label "github.com/bluesky-social/indigo/api/label" 14 13 15 14 "github.com/labstack/echo/v4" 16 15 "github.com/stretchr/testify/assert" ··· 176 175 assert.Equal(0, len(out1.Labels)) 177 176 178 177 // create a label, then query 179 179 - l3 := label.Label{ 178 178 + neg := false 179 179 + l3 := comatproto.LabelDefs_Label{ 180 180 Uri: "at://did:plc:fake/com.example/abc234", 181 181 Val: "example", 182 182 Cts: "2023-03-15T22:16:18.408Z", 183 183 + // TODO: temporary hack, should just be null 184 184 + Neg: &neg, 183 185 } 184 184 - lm.CommitLabels(ctx, []*label.Label{&l3}, false) 186 186 + lm.CommitLabels(ctx, []*comatproto.LabelDefs_Label{&l3}, false) 185 187 p3 := make(url.Values) 186 188 p3.Set("uriPatterns", l3.Uri) 187 189 out3, err := testQueryLabels(t, e, lm, &p3)

+3 -3

testing/labelmaker_fakedata_test.go

reviewed

··· 9 9 "testing" 10 10 "time" 11 11 12 12 - label "github.com/bluesky-social/indigo/api/label" 12 12 + comatproto "github.com/bluesky-social/indigo/api/atproto" 13 13 "github.com/bluesky-social/indigo/carstore" 14 14 "github.com/bluesky-social/indigo/events" 15 15 "github.com/bluesky-social/indigo/events/schedulers/sequential" ··· 101 101 102 102 go func() { 103 103 rsc := &events.RepoStreamCallbacks{ 104 104 - LabelLabels: func(evt *label.SubscribeLabels_Labels) error { 104 104 + LabelLabels: func(evt *comatproto.LabelSubscribeLabels_Labels) error { 105 105 fmt.Println("received event: ", evt.Seq) 106 106 es.Lk.Lock() 107 107 es.Events = append(es.Events, &events.XRPCStreamEvent{LabelLabels: evt}) ··· 164 164 } 165 165 166 166 // no auth required 167 167 - queryOut, err := label.QueryLabels(ctx, &xrpcc, "", 20, []string{}, []string{"*"}) 167 167 + queryOut, err := comatproto.LabelQueryLabels(ctx, &xrpcc, "", 20, []string{}, []string{"*"}) 168 168 assert.NoError(err) 169 169 assert.Equal(0, len(queryOut.Labels)) 170 170 assert.Nil(queryOut.Cursor)