+3 -1

.devcontainer/Dockerfile

··· 34 34 35 35 ENV PATH=/root/.bun/bin:$PATH 36 36 37 37 - RUN pkgx install node 37 37 + RUN pkgx install node go protoc buf 38 38 + 39 39 + RUN go get github.com/golang/protobuf/protoc-gen-go 38 40 39 41 ENV LANG=en_US.UTF-8 40 42

+255 -79

Cargo.lock

··· 138 138 checksum = "e01ed3140b2f8d422c68afa1ed2e85d996ea619c988ac834d255db32138655cb" 139 139 dependencies = [ 140 140 "quote", 141 141 - "syn 2.0.77", 141 141 + "syn 2.0.82", 142 142 ] 143 143 144 144 [[package]] ··· 273 273 "actix-router", 274 274 "proc-macro2", 275 275 "quote", 276 276 - "syn 2.0.77", 276 276 + "syn 2.0.82", 277 277 ] 278 278 279 279 [[package]] ··· 284 284 dependencies = [ 285 285 "proc-macro2", 286 286 "quote", 287 287 - "syn 2.0.77", 287 287 + "syn 2.0.82", 288 288 ] 289 289 290 290 [[package]] ··· 551 551 "proc-macro2", 552 552 "quote", 553 553 "swc_macros_common", 554 554 - "syn 2.0.77", 554 554 + "syn 2.0.82", 555 555 ] 556 556 557 557 [[package]] ··· 646 646 "proc-macro2", 647 647 "quote", 648 648 "strum 0.26.3", 649 649 - "syn 2.0.77", 649 649 + "syn 2.0.82", 650 650 "thiserror", 651 651 ] 652 652 ··· 693 693 dependencies = [ 694 694 "proc-macro2", 695 695 "quote", 696 696 - "syn 2.0.77", 696 696 + "syn 2.0.82", 697 697 ] 698 698 699 699 [[package]] ··· 704 704 dependencies = [ 705 705 "proc-macro2", 706 706 "quote", 707 707 - "syn 2.0.77", 707 707 + "syn 2.0.82", 708 708 ] 709 709 710 710 [[package]] ··· 892 892 "regex", 893 893 "rustc-hash 1.1.0", 894 894 "shlex", 895 895 - "syn 2.0.77", 895 895 + "syn 2.0.82", 896 896 "which 4.4.2", 897 897 ] 898 898 ··· 1404 1404 dependencies = [ 1405 1405 "proc-macro2", 1406 1406 "quote", 1407 1407 - "syn 2.0.77", 1407 1407 + "syn 2.0.82", 1408 1408 ] 1409 1409 1410 1410 [[package]] ··· 1439 1439 "proc-macro2", 1440 1440 "quote", 1441 1441 "strsim", 1442 1442 - "syn 2.0.77", 1442 1442 + "syn 2.0.82", 1443 1443 ] 1444 1444 1445 1445 [[package]] ··· 1450 1450 dependencies = [ 1451 1451 "darling_core", 1452 1452 "quote", 1453 1453 - "syn 2.0.77", 1453 1453 + "syn 2.0.82", 1454 1454 ] 1455 1455 1456 1456 [[package]] ··· 2025 2025 "quote", 2026 2026 "strum 0.25.0", 2027 2027 "strum_macros 0.25.3", 2028 2028 - "syn 2.0.77", 2028 2028 + "syn 2.0.82", 2029 2029 "thiserror", 2030 2030 ] 2031 2031 ··· 2414 2414 dependencies = [ 2415 2415 "proc-macro2", 2416 2416 "quote", 2417 2417 - "syn 2.0.77", 2417 2417 + "syn 2.0.82", 2418 2418 ] 2419 2419 2420 2420 [[package]] ··· 2436 2436 "proc-macro2", 2437 2437 "quote", 2438 2438 "rustc_version 0.4.1", 2439 2439 - "syn 2.0.77", 2439 2439 + "syn 2.0.82", 2440 2440 ] 2441 2441 2442 2442 [[package]] ··· 2459 2459 dependencies = [ 2460 2460 "proc-macro2", 2461 2461 "quote", 2462 2462 - "syn 2.0.77", 2462 2462 + "syn 2.0.82", 2463 2463 ] 2464 2464 2465 2465 [[package]] ··· 2494 2494 dependencies = [ 2495 2495 "proc-macro2", 2496 2496 "quote", 2497 2497 - "syn 2.0.77", 2497 2497 + "syn 2.0.82", 2498 2498 ] 2499 2499 2500 2500 [[package]] ··· 2681 2681 "heck 0.5.0", 2682 2682 "proc-macro2", 2683 2683 "quote", 2684 2684 - "syn 2.0.77", 2684 2684 + "syn 2.0.82", 2685 2685 ] 2686 2686 2687 2687 [[package]] ··· 2951 2951 dependencies = [ 2952 2952 "proc-macro2", 2953 2953 "quote", 2954 2954 - "syn 2.0.77", 2954 2954 + "syn 2.0.82", 2955 2955 ] 2956 2956 2957 2957 [[package]] ··· 2983 2983 dependencies = [ 2984 2984 "proc-macro2", 2985 2985 "swc_macros_common", 2986 2986 - "syn 2.0.77", 2986 2986 + "syn 2.0.82", 2987 2987 ] 2988 2988 2989 2989 [[package]] ··· 3017 3017 ] 3018 3018 3019 3019 [[package]] 3020 3020 + name = "fstr" 3021 3021 + version = "0.2.12" 3022 3022 + source = "registry+https://github.com/rust-lang/crates.io-index" 3023 3023 + checksum = "59fd8999da11407ccf70cbe696eb7f819b85429d83ee3c6eb2f514b1751d246b" 3024 3024 + 3025 3025 + [[package]] 3020 3026 name = "funty" 3021 3027 version = "2.0.0" 3022 3028 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 3089 3095 dependencies = [ 3090 3096 "proc-macro2", 3091 3097 "quote", 3092 3092 - "syn 2.0.77", 3098 3098 + "syn 2.0.82", 3093 3099 ] 3094 3100 3095 3101 [[package]] ··· 3354 3360 3355 3361 [[package]] 3356 3362 name = "heck" 3363 3363 + version = "0.3.3" 3364 3364 + source = "registry+https://github.com/rust-lang/crates.io-index" 3365 3365 + checksum = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c" 3366 3366 + dependencies = [ 3367 3367 + "unicode-segmentation", 3368 3368 + ] 3369 3369 + 3370 3370 + [[package]] 3371 3371 + name = "heck" 3357 3372 version = "0.4.1" 3358 3373 source = "registry+https://github.com/rust-lang/crates.io-index" 3359 3374 checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" ··· 3776 3791 "Inflector", 3777 3792 "proc-macro2", 3778 3793 "quote", 3779 3779 - "syn 2.0.77", 3794 3794 + "syn 2.0.82", 3780 3795 ] 3781 3796 3782 3797 [[package]] ··· 3938 3953 "proc-macro2", 3939 3954 "quote", 3940 3955 "regex", 3941 3941 - "syn 2.0.77", 3956 3956 + "syn 2.0.82", 3942 3957 ] 3943 3958 3944 3959 [[package]] ··· 4172 4187 dependencies = [ 4173 4188 "proc-macro2", 4174 4189 "quote", 4175 4175 - "syn 2.0.77", 4190 4190 + "syn 2.0.82", 4176 4191 ] 4177 4192 4178 4193 [[package]] ··· 4918 4933 "pest_meta", 4919 4934 "proc-macro2", 4920 4935 "quote", 4921 4921 - "syn 2.0.77", 4936 4936 + "syn 2.0.82", 4922 4937 ] 4923 4938 4924 4939 [[package]] ··· 4972 4987 "phf_shared", 4973 4988 "proc-macro2", 4974 4989 "quote", 4975 4975 - "syn 2.0.77", 4990 4990 + "syn 2.0.82", 4976 4991 ] 4977 4992 4978 4993 [[package]] ··· 5001 5016 dependencies = [ 5002 5017 "proc-macro2", 5003 5018 "quote", 5004 5004 - "syn 2.0.77", 5019 5019 + "syn 2.0.82", 5005 5020 ] 5006 5021 5007 5022 [[package]] ··· 5117 5132 checksum = "479cf940fbbb3426c32c5d5176f62ad57549a0bb84773423ba8be9d089f5faba" 5118 5133 dependencies = [ 5119 5134 "proc-macro2", 5120 5120 - "syn 2.0.77", 5135 5135 + "syn 2.0.82", 5121 5136 ] 5122 5137 5123 5138 [[package]] ··· 5170 5185 dependencies = [ 5171 5186 "proc-macro-rules-macros", 5172 5187 "proc-macro2", 5173 5173 - "syn 2.0.77", 5188 5188 + "syn 2.0.82", 5174 5189 ] 5175 5190 5176 5191 [[package]] ··· 5182 5197 "once_cell", 5183 5198 "proc-macro2", 5184 5199 "quote", 5185 5185 - "syn 2.0.77", 5200 5200 + "syn 2.0.82", 5186 5201 ] 5187 5202 5188 5203 [[package]] ··· 5202 5217 5203 5218 [[package]] 5204 5219 name = "prost" 5220 5220 + version = "0.9.0" 5221 5221 + source = "registry+https://github.com/rust-lang/crates.io-index" 5222 5222 + checksum = "444879275cb4fd84958b1a1d5420d15e6fcf7c235fe47f053c9c2a80aceb6001" 5223 5223 + dependencies = [ 5224 5224 + "bytes", 5225 5225 + "prost-derive 0.9.0", 5226 5226 + ] 5227 5227 + 5228 5228 + [[package]] 5229 5229 + name = "prost" 5205 5230 version = "0.11.9" 5206 5231 source = "registry+https://github.com/rust-lang/crates.io-index" 5207 5232 checksum = "0b82eaa1d779e9a4bc1c3217db8ffbeabaae1dca241bf70183242128d48681cd" ··· 5212 5237 5213 5238 [[package]] 5214 5239 name = "prost" 5215 5215 - version = "0.13.2" 5240 5240 + version = "0.12.6" 5241 5241 + source = "registry+https://github.com/rust-lang/crates.io-index" 5242 5242 + checksum = "deb1435c188b76130da55f17a466d252ff7b1418b2ad3e037d127b94e3411f29" 5243 5243 + dependencies = [ 5244 5244 + "bytes", 5245 5245 + "prost-derive 0.12.6", 5246 5246 + ] 5247 5247 + 5248 5248 + [[package]] 5249 5249 + name = "prost" 5250 5250 + version = "0.13.3" 5216 5251 source = "registry+https://github.com/rust-lang/crates.io-index" 5217 5217 - checksum = "3b2ecbe40f08db5c006b5764a2645f7f3f141ce756412ac9e1dd6087e6d32995" 5252 5252 + checksum = "7b0487d90e047de87f984913713b85c601c05609aad5b0df4b4573fbf69aa13f" 5218 5253 dependencies = [ 5219 5254 "bytes", 5220 5220 - "prost-derive 0.13.2", 5255 5255 + "prost-derive 0.13.3", 5256 5256 + ] 5257 5257 + 5258 5258 + [[package]] 5259 5259 + name = "prost-build" 5260 5260 + version = "0.9.0" 5261 5261 + source = "registry+https://github.com/rust-lang/crates.io-index" 5262 5262 + checksum = "62941722fb675d463659e49c4f3fe1fe792ff24fe5bbaa9c08cd3b98a1c354f5" 5263 5263 + dependencies = [ 5264 5264 + "bytes", 5265 5265 + "heck 0.3.3", 5266 5266 + "itertools 0.10.5", 5267 5267 + "lazy_static", 5268 5268 + "log", 5269 5269 + "multimap 0.8.3", 5270 5270 + "petgraph", 5271 5271 + "prost 0.9.0", 5272 5272 + "prost-types 0.9.0", 5273 5273 + "regex", 5274 5274 + "tempfile", 5275 5275 + "which 4.4.2", 5221 5276 ] 5222 5277 5223 5278 [[package]] ··· 5244 5299 5245 5300 [[package]] 5246 5301 name = "prost-build" 5247 5247 - version = "0.13.2" 5302 5302 + version = "0.13.3" 5248 5303 source = "registry+https://github.com/rust-lang/crates.io-index" 5249 5249 - checksum = "f8650aabb6c35b860610e9cff5dc1af886c9e25073b7b1712a68972af4281302" 5304 5304 + checksum = "0c1318b19085f08681016926435853bbf7858f9c082d0999b80550ff5d9abe15" 5250 5305 dependencies = [ 5251 5306 "bytes", 5252 5307 "heck 0.5.0", ··· 5256 5311 "once_cell", 5257 5312 "petgraph", 5258 5313 "prettyplease 0.2.22", 5259 5259 - "prost 0.13.2", 5260 5260 - "prost-types 0.13.2", 5314 5314 + "prost 0.13.3", 5315 5315 + "prost-types 0.13.3", 5261 5316 "regex", 5262 5262 - "syn 2.0.77", 5317 5317 + "syn 2.0.82", 5263 5318 "tempfile", 5264 5319 ] 5265 5320 5266 5321 [[package]] 5267 5322 name = "prost-derive" 5323 5323 + version = "0.9.0" 5324 5324 + source = "registry+https://github.com/rust-lang/crates.io-index" 5325 5325 + checksum = "f9cc1a3263e07e0bf68e96268f37665207b49560d98739662cdfaae215c720fe" 5326 5326 + dependencies = [ 5327 5327 + "anyhow", 5328 5328 + "itertools 0.10.5", 5329 5329 + "proc-macro2", 5330 5330 + "quote", 5331 5331 + "syn 1.0.109", 5332 5332 + ] 5333 5333 + 5334 5334 + [[package]] 5335 5335 + name = "prost-derive" 5268 5336 version = "0.11.9" 5269 5337 source = "registry+https://github.com/rust-lang/crates.io-index" 5270 5338 checksum = "e5d2d8d10f3c6ded6da8b05b5fb3b8a5082514344d56c9f871412d29b4e075b4" ··· 5278 5346 5279 5347 [[package]] 5280 5348 name = "prost-derive" 5281 5281 - version = "0.13.2" 5349 5349 + version = "0.12.6" 5350 5350 + source = "registry+https://github.com/rust-lang/crates.io-index" 5351 5351 + checksum = "81bddcdb20abf9501610992b6759a4c888aef7d1a7247ef75e2404275ac24af1" 5352 5352 + dependencies = [ 5353 5353 + "anyhow", 5354 5354 + "itertools 0.12.1", 5355 5355 + "proc-macro2", 5356 5356 + "quote", 5357 5357 + "syn 2.0.82", 5358 5358 + ] 5359 5359 + 5360 5360 + [[package]] 5361 5361 + name = "prost-derive" 5362 5362 + version = "0.13.3" 5282 5363 source = "registry+https://github.com/rust-lang/crates.io-index" 5283 5283 - checksum = "acf0c195eebb4af52c752bec4f52f645da98b6e92077a04110c7f349477ae5ac" 5364 5364 + checksum = "e9552f850d5f0964a4e4d0bf306459ac29323ddfbae05e35a7c0d35cb0803cc5" 5284 5365 dependencies = [ 5285 5366 "anyhow", 5286 5367 "itertools 0.13.0", 5287 5368 "proc-macro2", 5288 5369 "quote", 5289 5289 - "syn 2.0.77", 5370 5370 + "syn 2.0.82", 5371 5371 + ] 5372 5372 + 5373 5373 + [[package]] 5374 5374 + name = "prost-helper" 5375 5375 + version = "0.8.3" 5376 5376 + source = "registry+https://github.com/rust-lang/crates.io-index" 5377 5377 + checksum = "8c3aa986c9382cffc2613c2e03e57500bfd9232c98903fbdeaaebb18af42e53f" 5378 5378 + dependencies = [ 5379 5379 + "base64 0.21.7", 5380 5380 + "bytes", 5381 5381 + "num-traits", 5382 5382 + "prost 0.12.6", 5383 5383 + "serde", 5384 5384 + "serde_json", 5385 5385 + "uuid7", 5386 5386 + ] 5387 5387 + 5388 5388 + [[package]] 5389 5389 + name = "prost-serde" 5390 5390 + version = "0.3.0" 5391 5391 + source = "registry+https://github.com/rust-lang/crates.io-index" 5392 5392 + checksum = "6ba72101a1eb9e65d7f751d9aa8745df8fca7b4a01fc06ae2ff2f97d8c888f49" 5393 5393 + dependencies = [ 5394 5394 + "prost-build 0.9.0", 5395 5395 + "serde", 5396 5396 + "serde_json", 5397 5397 + ] 5398 5398 + 5399 5399 + [[package]] 5400 5400 + name = "prost-types" 5401 5401 + version = "0.9.0" 5402 5402 + source = "registry+https://github.com/rust-lang/crates.io-index" 5403 5403 + checksum = "534b7a0e836e3c482d2693070f982e39e7611da9695d4d1f5a4b186b51faef0a" 5404 5404 + dependencies = [ 5405 5405 + "bytes", 5406 5406 + "prost 0.9.0", 5290 5407 ] 5291 5408 5292 5409 [[package]] ··· 5300 5417 5301 5418 [[package]] 5302 5419 name = "prost-types" 5303 5303 - version = "0.13.2" 5420 5420 + version = "0.13.3" 5304 5421 source = "registry+https://github.com/rust-lang/crates.io-index" 5305 5305 - checksum = "60caa6738c7369b940c3d49246a8d1749323674c65cb13010134f5c9bad5b519" 5422 5422 + checksum = "4759aa0d3a6232fb8dbdb97b61de2c20047c68aca932c7ed76da9d788508d670" 5306 5423 dependencies = [ 5307 5307 - "prost 0.13.2", 5424 5424 + "prost 0.13.3", 5308 5425 ] 5309 5426 5310 5427 [[package]] ··· 5516 5633 dependencies = [ 5517 5634 "proc-macro2", 5518 5635 "quote", 5519 5519 - "syn 2.0.77", 5636 5636 + "syn 2.0.82", 5520 5637 ] 5521 5638 5522 5639 [[package]] ··· 5697 5814 "owo-colors 4.1.0", 5698 5815 "reqwest", 5699 5816 "rockbox-library", 5817 5817 + "rockbox-search", 5700 5818 "rockbox-sys", 5819 5819 + "rockbox-types", 5701 5820 "rockbox-webui", 5702 5821 "serde", 5703 5822 "serde_json", ··· 5717 5836 "lofty", 5718 5837 "md5", 5719 5838 "owo-colors 4.1.0", 5839 5839 + "rockbox-search", 5720 5840 "rockbox-sys", 5721 5841 "serde", 5722 5842 "sqlx", ··· 5732 5852 "cuid", 5733 5853 "futures", 5734 5854 "owo-colors 5.0.0", 5735 5735 - "prost 0.13.2", 5855 5855 + "prost 0.13.3", 5736 5856 "reqwest", 5737 5857 "rockbox-library", 5858 5858 + "rockbox-search", 5738 5859 "rockbox-sys", 5860 5860 + "rockbox-types", 5739 5861 "serde", 5740 5862 "serde_json", 5741 5863 "sqlx", ··· 5747 5869 ] 5748 5870 5749 5871 [[package]] 5872 5872 + name = "rockbox-search" 5873 5873 + version = "0.1.0" 5874 5874 + dependencies = [ 5875 5875 + "anyhow", 5876 5876 + "prost 0.13.3", 5877 5877 + "prost-build 0.13.3", 5878 5878 + "prost-helper", 5879 5879 + "prost-serde", 5880 5880 + "prost-types 0.13.3", 5881 5881 + "serde", 5882 5882 + "serde_yaml", 5883 5883 + ] 5884 5884 + 5885 5885 + [[package]] 5750 5886 name = "rockbox-server" 5751 5887 version = "0.1.0" 5752 5888 dependencies = [ ··· 5759 5895 "rockbox-graphql", 5760 5896 "rockbox-library", 5761 5897 "rockbox-rpc", 5898 5898 + "rockbox-search", 5762 5899 "rockbox-sys", 5900 5900 + "rockbox-types", 5763 5901 "serde", 5764 5902 "serde_json", 5765 5903 "sqlx", ··· 5772 5910 version = "0.1.0" 5773 5911 dependencies = [ 5774 5912 "anyhow", 5913 5913 + "serde", 5914 5914 + ] 5915 5915 + 5916 5916 + [[package]] 5917 5917 + name = "rockbox-types" 5918 5918 + version = "0.1.0" 5919 5919 + dependencies = [ 5920 5920 + "rockbox-search", 5775 5921 "serde", 5776 5922 ] 5777 5923 ··· 5853 5999 "proc-macro2", 5854 6000 "quote", 5855 6001 "rust-embed-utils", 5856 5856 - "syn 2.0.77", 6002 6002 + "syn 2.0.82", 5857 6003 "walkdir", 5858 6004 ] 5859 6005 ··· 6154 6300 6155 6301 [[package]] 6156 6302 name = "serde" 6157 6157 - version = "1.0.210" 6303 6303 + version = "1.0.213" 6158 6304 source = "registry+https://github.com/rust-lang/crates.io-index" 6159 6159 - checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a" 6305 6305 + checksum = "3ea7893ff5e2466df8d720bb615088341b295f849602c6956047f8f80f0e9bc1" 6160 6306 dependencies = [ 6161 6307 "serde_derive", 6162 6308 ] ··· 6182 6328 6183 6329 [[package]] 6184 6330 name = "serde_derive" 6185 6185 - version = "1.0.210" 6331 6331 + version = "1.0.213" 6186 6332 source = "registry+https://github.com/rust-lang/crates.io-index" 6187 6187 - checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f" 6333 6333 + checksum = "7e85ad2009c50b58e87caa8cd6dac16bdf511bbfb7af6c33df902396aa480fa5" 6188 6334 dependencies = [ 6189 6335 "proc-macro2", 6190 6336 "quote", 6191 6191 - "syn 2.0.77", 6337 6337 + "syn 2.0.82", 6192 6338 ] 6193 6339 6194 6340 [[package]] ··· 6230 6376 ] 6231 6377 6232 6378 [[package]] 6379 6379 + name = "serde_yaml" 6380 6380 + version = "0.9.34+deprecated" 6381 6381 + source = "registry+https://github.com/rust-lang/crates.io-index" 6382 6382 + checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47" 6383 6383 + dependencies = [ 6384 6384 + "indexmap 2.5.0", 6385 6385 + "itoa", 6386 6386 + "ryu", 6387 6387 + "serde", 6388 6388 + "unsafe-libyaml", 6389 6389 + ] 6390 6390 + 6391 6391 + [[package]] 6233 6392 name = "serdect" 6234 6393 version = "0.2.0" 6235 6394 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 6529 6688 "quote", 6530 6689 "sqlx-core", 6531 6690 "sqlx-macros-core", 6532 6532 - "syn 2.0.77", 6691 6691 + "syn 2.0.82", 6533 6692 ] 6534 6693 6535 6694 [[package]] ··· 6552 6711 "sqlx-mysql", 6553 6712 "sqlx-postgres", 6554 6713 "sqlx-sqlite", 6555 6555 - "syn 2.0.77", 6714 6714 + "syn 2.0.82", 6556 6715 "tempfile", 6557 6716 "tokio", 6558 6717 "url", ··· 6704 6863 "proc-macro2", 6705 6864 "quote", 6706 6865 "swc_macros_common", 6707 6707 - "syn 2.0.77", 6866 6866 + "syn 2.0.82", 6708 6867 ] 6709 6868 6710 6869 [[package]] ··· 6752 6911 "proc-macro2", 6753 6912 "quote", 6754 6913 "rustversion", 6755 6755 - "syn 2.0.77", 6914 6914 + "syn 2.0.82", 6756 6915 ] 6757 6916 6758 6917 [[package]] ··· 6765 6924 "proc-macro2", 6766 6925 "quote", 6767 6926 "rustversion", 6768 6768 - "syn 2.0.77", 6927 6927 + "syn 2.0.82", 6769 6928 ] 6770 6929 6771 6930 [[package]] ··· 6863 7022 "proc-macro2", 6864 7023 "quote", 6865 7024 "swc_macros_common", 6866 6866 - "syn 2.0.77", 7025 7025 + "syn 2.0.82", 6867 7026 ] 6868 7027 6869 7028 [[package]] ··· 6912 7071 "proc-macro2", 6913 7072 "quote", 6914 7073 "swc_macros_common", 6915 6915 - "syn 2.0.77", 7074 7074 + "syn 2.0.82", 6916 7075 ] 6917 7076 6918 7077 [[package]] ··· 6997 7156 "proc-macro2", 6998 7157 "quote", 6999 7158 "swc_macros_common", 7000 7000 - "syn 2.0.77", 7159 7159 + "syn 2.0.82", 7001 7160 ] 7002 7161 7003 7162 [[package]] ··· 7104 7263 dependencies = [ 7105 7264 "proc-macro2", 7106 7265 "quote", 7107 7107 - "syn 2.0.77", 7266 7266 + "syn 2.0.82", 7108 7267 ] 7109 7268 7110 7269 [[package]] ··· 7115 7274 dependencies = [ 7116 7275 "proc-macro2", 7117 7276 "quote", 7118 7118 - "syn 2.0.77", 7277 7277 + "syn 2.0.82", 7119 7278 ] 7120 7279 7121 7280 [[package]] ··· 7137 7296 "proc-macro2", 7138 7297 "quote", 7139 7298 "swc_macros_common", 7140 7140 - "syn 2.0.77", 7299 7299 + "syn 2.0.82", 7141 7300 ] 7142 7301 7143 7302 [[package]] ··· 7153 7312 7154 7313 [[package]] 7155 7314 name = "syn" 7156 7156 - version = "2.0.77" 7315 7315 + version = "2.0.82" 7157 7316 source = "registry+https://github.com/rust-lang/crates.io-index" 7158 7158 - checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed" 7317 7317 + checksum = "83540f837a8afc019423a8edb95b52a8effe46957ee402287f4292fae35be021" 7159 7318 dependencies = [ 7160 7319 "proc-macro2", 7161 7320 "quote", ··· 7197 7356 dependencies = [ 7198 7357 "proc-macro2", 7199 7358 "quote", 7200 7200 - "syn 2.0.77", 7359 7359 + "syn 2.0.82", 7201 7360 ] 7202 7361 7203 7362 [[package]] ··· 7254 7413 dependencies = [ 7255 7414 "proc-macro2", 7256 7415 "quote", 7257 7257 - "syn 2.0.77", 7416 7416 + "syn 2.0.82", 7258 7417 ] 7259 7418 7260 7419 [[package]] ··· 7339 7498 dependencies = [ 7340 7499 "proc-macro2", 7341 7500 "quote", 7342 7342 - "syn 2.0.77", 7501 7501 + "syn 2.0.82", 7343 7502 ] 7344 7503 7345 7504 [[package]] ··· 7442 7601 "hyper-util", 7443 7602 "percent-encoding", 7444 7603 "pin-project", 7445 7445 - "prost 0.13.2", 7604 7604 + "prost 0.13.3", 7446 7605 "socket2", 7447 7606 "tokio", 7448 7607 "tokio-stream", ··· 7460 7619 dependencies = [ 7461 7620 "prettyplease 0.2.22", 7462 7621 "proc-macro2", 7463 7463 - "prost-build 0.13.2", 7622 7622 + "prost-build 0.13.3", 7464 7623 "quote", 7465 7465 - "syn 2.0.77", 7624 7624 + "syn 2.0.82", 7466 7625 ] 7467 7626 7468 7627 [[package]] ··· 7471 7630 source = "registry+https://github.com/rust-lang/crates.io-index" 7472 7631 checksum = "7b56b874eedb04f89907573b408eab1e87c1c1dce43aac6ad63742f57faa99ff" 7473 7632 dependencies = [ 7474 7474 - "prost 0.13.2", 7475 7475 - "prost-types 0.13.2", 7633 7633 + "prost 0.13.3", 7634 7634 + "prost-types 0.13.3", 7476 7635 "tokio", 7477 7636 "tokio-stream", 7478 7637 "tonic", ··· 7570 7729 dependencies = [ 7571 7730 "proc-macro2", 7572 7731 "quote", 7573 7573 - "syn 2.0.77", 7732 7732 + "syn 2.0.82", 7574 7733 ] 7575 7734 7576 7735 [[package]] ··· 7799 7958 ] 7800 7959 7801 7960 [[package]] 7961 7961 + name = "unsafe-libyaml" 7962 7962 + version = "0.2.11" 7963 7963 + source = "registry+https://github.com/rust-lang/crates.io-index" 7964 7964 + checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861" 7965 7965 + 7966 7966 + [[package]] 7802 7967 name = "untrusted" 7803 7968 version = "0.9.0" 7804 7969 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 7851 8016 ] 7852 8017 7853 8018 [[package]] 8019 8019 + name = "uuid7" 8020 8020 + version = "0.7.2" 8021 8021 + source = "registry+https://github.com/rust-lang/crates.io-index" 8022 8022 + checksum = "fcba843a27a44d6bfbc8852222af425ebd04da999d898df30fd2ed16abe469ac" 8023 8023 + dependencies = [ 8024 8024 + "fstr", 8025 8025 + "rand", 8026 8026 + "rand_chacha", 8027 8027 + ] 8028 8028 + 8029 8029 + [[package]] 7854 8030 name = "v8" 7855 8031 version = "0.105.1" 7856 8032 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 7971 8147 "once_cell", 7972 8148 "proc-macro2", 7973 8149 "quote", 7974 7974 - "syn 2.0.77", 8150 8150 + "syn 2.0.82", 7975 8151 "wasm-bindgen-shared", 7976 8152 ] 7977 8153 ··· 8005 8181 dependencies = [ 8006 8182 "proc-macro2", 8007 8183 "quote", 8008 8008 - "syn 2.0.77", 8184 8184 + "syn 2.0.82", 8009 8185 "wasm-bindgen-backend", 8010 8186 "wasm-bindgen-shared", 8011 8187 ] ··· 8482 8658 dependencies = [ 8483 8659 "proc-macro2", 8484 8660 "quote", 8485 8485 - "syn 2.0.77", 8661 8661 + "syn 2.0.82", 8486 8662 "synstructure 0.13.1", 8487 8663 ] 8488 8664 ··· 8504 8680 dependencies = [ 8505 8681 "proc-macro2", 8506 8682 "quote", 8507 8507 - "syn 2.0.77", 8683 8683 + "syn 2.0.82", 8508 8684 ] 8509 8685 8510 8686 [[package]] ··· 8524 8700 dependencies = [ 8525 8701 "proc-macro2", 8526 8702 "quote", 8527 8527 - "syn 2.0.77", 8703 8703 + "syn 2.0.82", 8528 8704 "synstructure 0.13.1", 8529 8705 ] 8530 8706 ··· 8545 8721 dependencies = [ 8546 8722 "proc-macro2", 8547 8723 "quote", 8548 8548 - "syn 2.0.77", 8724 8724 + "syn 2.0.82", 8549 8725 ] 8550 8726 8551 8727 [[package]]

+3 -1

Dockerfile

··· 12 12 13 13 RUN curl -Ssf https://pkgx.sh | sh 14 14 15 15 - RUN pkgx install zig@0.13.0 node bun@1.1.30 15 15 + RUN pkgx install zig@0.13.0 node bun@1.1.30 go protoc buf 16 16 + 17 17 + RUN go get github.com/golang/protobuf/protoc-gen-go 16 18 17 19 COPY . /app 18 20

+4

build.zig

··· 2925 2925 exe.addLibraryPath(.{ 2926 2926 .cwd_relative = "./target/release", 2927 2927 }); 2928 2928 + exe.addLibraryPath(.{ 2929 2929 + .cwd_relative = "./search", 2930 2930 + }); 2928 2931 exe.linkSystemLibrary("rockbox_cli"); 2932 2932 + exe.linkSystemLibrary("rockboxsearch"); 2929 2933 exe.linkSystemLibrary("rockbox_server"); 2930 2934 exe.linkSystemLibrary("libunwind"); 2931 2935 exe.linkLibrary(libfirmware);

+2

crates/graphql/Cargo.toml

··· 20 20 owo-colors = "4.1.0" 21 21 reqwest = {version = "0.12.7", features = ["rustls-tls", "json"], default-features = false} 22 22 rockbox-library = {path = "../library"} 23 23 + rockbox-search = {path = "../search"} 23 24 rockbox-sys = {path = "../sys"} 25 25 + rockbox-types = {path = "../types"} 24 26 rockbox-webui = {path = "../../webui"} 25 27 serde = "1.0.210" 26 28 serde_json = "1.0.128"

+16 -9

crates/graphql/src/schema/library.rs

··· 1 1 - use std::env; 2 2 - 3 1 use async_graphql::*; 4 4 - use rockbox_library::{audio_scan::scan_audio_files, entity::favourites::Favourites, repo}; 2 2 + use rockbox_library::{entity::favourites::Favourites, repo}; 5 3 use sqlx::{Pool, Sqlite}; 6 4 7 7 - use crate::schema::objects::track::Track; 5 5 + use crate::{rockbox_url, schema::objects::track::Track}; 8 6 9 9 - use super::objects::{album::Album, artist::Artist}; 7 7 + use super::objects::{album::Album, artist::Artist, search::SearchResults}; 10 8 11 9 #[derive(Default)] 12 10 pub struct LibraryQuery; ··· 74 72 let results = repo::favourites::all_albums(pool.clone()).await?; 75 73 Ok(results.into_iter().map(Into::into).collect()) 76 74 } 75 75 + 76 76 + async fn search(&self, ctx: &Context<'_>, term: String) -> Result<SearchResults, Error> { 77 77 + let client = ctx.data::<reqwest::Client>().unwrap(); 78 78 + 79 79 + let url = format!("{}/search?q={}", rockbox_url(), term); 80 80 + let response = client.get(&url).send().await?; 81 81 + let results = response.json::<rockbox_types::SearchResults>().await?; 82 82 + 83 83 + Ok(results.into()) 84 84 + } 77 85 } 78 86 79 87 #[derive(Default)] ··· 124 132 } 125 133 126 134 async fn scan_library(&self, ctx: &Context<'_>) -> Result<i32, Error> { 127 127 - let pool = ctx.data::<Pool<Sqlite>>()?; 128 128 - let home = env::var("HOME")?; 129 129 - let path = env::var("ROCKBOX_LIBRARY").unwrap_or(format!("{}/Music", home)); 130 130 - scan_audio_files(pool.clone(), path.into()).await?; 135 135 + let client = ctx.data::<reqwest::Client>().unwrap(); 136 136 + let url = format!("{}/scan-library", rockbox_url()); 137 137 + client.put(&url).send().await?; 131 138 Ok(0) 132 139 } 133 140 }

+33

crates/graphql/src/schema/objects/album.rs

··· 70 70 } 71 71 } 72 72 } 73 73 + 74 74 + impl From<rockbox_search::rockbox::search::v1alpha1::Album> for Album { 75 75 + fn from(album: rockbox_search::rockbox::search::v1alpha1::Album) -> Self { 76 76 + Self { 77 77 + id: album.id, 78 78 + title: album.title, 79 79 + artist: album.artist, 80 80 + year: album.year, 81 81 + year_string: album.year_string, 82 82 + album_art: album.album_art, 83 83 + md5: album.md5, 84 84 + artist_id: album.artist_id, 85 85 + tracks: vec![], 86 86 + } 87 87 + } 88 88 + } 89 89 + 90 90 + 91 91 + impl From<rockbox_search::rockbox::search::v1alpha1::LikedAlbum> for Album { 92 92 + fn from(album: rockbox_search::rockbox::search::v1alpha1::LikedAlbum) -> Self { 93 93 + Self { 94 94 + id: album.id, 95 95 + title: album.title, 96 96 + artist: album.artist, 97 97 + year: album.year, 98 98 + year_string: album.year_string, 99 99 + album_art: album.album_art, 100 100 + md5: album.md5, 101 101 + artist_id: album.artist_id, 102 102 + tracks: vec![], 103 103 + } 104 104 + } 105 105 + }

+13

crates/graphql/src/schema/objects/artist.rs

··· 52 52 } 53 53 } 54 54 } 55 55 + 56 56 + impl From<rockbox_search::rockbox::search::v1alpha1::Artist> for Artist { 57 57 + fn from(artist: rockbox_search::rockbox::search::v1alpha1::Artist) -> Self { 58 58 + Self { 59 59 + id: artist.id, 60 60 + name: artist.name, 61 61 + bio: artist.bio, 62 62 + image: artist.image, 63 63 + tracks: vec![], 64 64 + albums: vec![], 65 65 + } 66 66 + } 67 67 + }

+1

crates/graphql/src/schema/objects/mod.rs

··· 6 6 pub mod eq_band_setting; 7 7 pub mod playlist; 8 8 pub mod replaygain_settings; 9 9 + pub mod search; 9 10 pub mod settings_list; 10 11 pub mod system_status; 11 12 pub mod track;

+48

crates/graphql/src/schema/objects/search.rs

··· 1 1 + use async_graphql::*; 2 2 + use serde::{Deserialize, Serialize}; 3 3 + 4 4 + use super::{album::Album, artist::Artist, track::Track}; 5 5 + 6 6 + #[derive(Default, Clone, Serialize, Deserialize)] 7 7 + pub struct SearchResults { 8 8 + pub artists: Vec<Artist>, 9 9 + pub albums: Vec<Album>, 10 10 + pub tracks: Vec<Track>, 11 11 + pub liked_tracks: Vec<Track>, 12 12 + pub liked_albums: Vec<Album>, 13 13 + } 14 14 + 15 15 + #[Object] 16 16 + impl SearchResults { 17 17 + async fn artists(&self) -> Vec<Artist> { 18 18 + self.artists.clone() 19 19 + } 20 20 + 21 21 + async fn albums(&self) -> Vec<Album> { 22 22 + self.albums.clone() 23 23 + } 24 24 + 25 25 + async fn tracks(&self) -> Vec<Track> { 26 26 + self.tracks.clone() 27 27 + } 28 28 + 29 29 + async fn liked_tracks(&self) -> Vec<Track> { 30 30 + self.liked_tracks.clone() 31 31 + } 32 32 + 33 33 + async fn liked_albums(&self) -> Vec<Album> { 34 34 + self.liked_albums.clone() 35 35 + } 36 36 + } 37 37 + 38 38 + impl From<rockbox_types::SearchResults> for SearchResults { 39 39 + fn from(results: rockbox_types::SearchResults) -> Self { 40 40 + SearchResults { 41 41 + artists: results.artists.into_iter().map(Into::into).collect(), 42 42 + albums: results.albums.into_iter().map(Into::into).collect(), 43 43 + tracks: results.tracks.into_iter().map(Into::into).collect(), 44 44 + liked_tracks: results.liked_tracks.into_iter().map(Into::into).collect(), 45 45 + liked_albums: results.liked_albums.into_iter().map(Into::into).collect(), 46 46 + } 47 47 + } 48 48 + }

+56

crates/graphql/src/schema/objects/track.rs

··· 225 225 } 226 226 } 227 227 } 228 228 + 229 229 + impl From<rockbox_search::rockbox::search::v1alpha1::Track> for Track { 230 230 + fn from(track: rockbox_search::rockbox::search::v1alpha1::Track) -> Self { 231 231 + Self { 232 232 + id: Some(track.id), 233 233 + title: track.title, 234 234 + artist: track.artist, 235 235 + album: track.album, 236 236 + genre: track.genre, 237 237 + year_string: track.year_string, 238 238 + composer: track.composer, 239 239 + album_artist: track.album_artist, 240 240 + discnum: track.disc_number as i32, 241 241 + tracknum: track.track_number as i32, 242 242 + year: track.year as i32, 243 243 + bitrate: track.bitrate, 244 244 + frequency: track.frequency as u64, 245 245 + filesize: track.filesize as u64, 246 246 + length: track.length as u64, 247 247 + artist_id: track.artist_id, 248 248 + album_id: track.album_id, 249 249 + genre_id: track.genre_id, 250 250 + path: track.path, 251 251 + album_art: track.album_art, 252 252 + ..Default::default() 253 253 + } 254 254 + } 255 255 + } 256 256 + 257 257 + impl From<rockbox_search::rockbox::search::v1alpha1::LikedTrack> for Track { 258 258 + fn from(track: rockbox_search::rockbox::search::v1alpha1::LikedTrack) -> Self { 259 259 + Self { 260 260 + id: Some(track.id), 261 261 + title: track.title, 262 262 + artist: track.artist, 263 263 + album: track.album, 264 264 + genre: track.genre, 265 265 + year_string: track.year_string, 266 266 + composer: track.composer, 267 267 + album_artist: track.album_artist, 268 268 + discnum: track.disc_number as i32, 269 269 + tracknum: track.track_number as i32, 270 270 + year: track.year as i32, 271 271 + bitrate: track.bitrate, 272 272 + frequency: track.frequency as u64, 273 273 + filesize: track.filesize as u64, 274 274 + length: track.length as u64, 275 275 + artist_id: track.artist_id, 276 276 + album_id: track.album_id, 277 277 + genre_id: track.genre_id, 278 278 + path: track.path, 279 279 + album_art: track.album_art, 280 280 + ..Default::default() 281 281 + } 282 282 + } 283 283 + }

+1

crates/library/Cargo.toml

··· 11 11 lofty = "0.21.1" 12 12 md5 = "0.7.0" 13 13 owo-colors = "4.1.0" 14 14 + rockbox-search = {path = "../search"} 14 15 rockbox-sys = {path = "../sys"} 15 16 serde = "1.0.210" 16 17 sqlx = {version = "0.8.2", features = ["runtime-tokio", "tls-rustls", "sqlite", "chrono", "derive", "macros"]}

+31 -1

crates/library/src/entity/album.rs

··· 1 1 use serde::{Deserialize, Serialize}; 2 2 3 3 - #[derive(sqlx::FromRow, Default, Serialize, Deserialize)] 3 3 + #[derive(sqlx::FromRow, Default, Serialize, Deserialize, Clone)] 4 4 pub struct Album { 5 5 pub id: String, 6 6 pub title: String, ··· 12 12 pub md5: String, 13 13 pub artist_id: String, 14 14 } 15 15 + 16 16 + impl Into<rockbox_search::rockbox::search::v1alpha1::Album> for Album { 17 17 + fn into(self) -> rockbox_search::rockbox::search::v1alpha1::Album { 18 18 + rockbox_search::rockbox::search::v1alpha1::Album { 19 19 + id: self.id, 20 20 + title: self.title, 21 21 + artist: self.artist, 22 22 + year: self.year, 23 23 + year_string: self.year_string, 24 24 + album_art: self.album_art, 25 25 + md5: self.md5, 26 26 + artist_id: self.artist_id, 27 27 + } 28 28 + } 29 29 + } 30 30 + 31 31 + impl Into<rockbox_search::rockbox::search::v1alpha1::LikedAlbum> for Album { 32 32 + fn into(self) -> rockbox_search::rockbox::search::v1alpha1::LikedAlbum { 33 33 + rockbox_search::rockbox::search::v1alpha1::LikedAlbum { 34 34 + id: self.id, 35 35 + title: self.title, 36 36 + artist: self.artist, 37 37 + year: self.year, 38 38 + year_string: self.year_string, 39 39 + album_art: self.album_art, 40 40 + md5: self.md5, 41 41 + artist_id: self.artist_id, 42 42 + } 43 43 + } 44 44 + }

+12 -1

crates/library/src/entity/artist.rs

··· 1 1 use serde::{Deserialize, Serialize}; 2 2 3 3 - #[derive(sqlx::FromRow, Default, Serialize, Deserialize)] 3 3 + #[derive(sqlx::FromRow, Default, Serialize, Deserialize, Clone)] 4 4 pub struct Artist { 5 5 pub id: String, 6 6 pub name: String, ··· 9 9 #[serde(skip_serializing_if = "Option::is_none")] 10 10 pub image: Option<String>, 11 11 } 12 12 + 13 13 + impl Into<rockbox_search::rockbox::search::v1alpha1::Artist> for Artist { 14 14 + fn into(self) -> rockbox_search::rockbox::search::v1alpha1::Artist { 15 15 + rockbox_search::rockbox::search::v1alpha1::Artist { 16 16 + id: self.id, 17 17 + name: self.name, 18 18 + bio: self.bio, 19 19 + image: self.image, 20 20 + } 21 21 + } 22 22 + }

+60

crates/library/src/entity/track.rs

··· 34 34 #[serde(with = "chrono::serde::ts_seconds")] 35 35 pub updated_at: DateTime<Utc>, 36 36 } 37 37 + 38 38 + impl Into<rockbox_search::rockbox::search::v1alpha1::Track> for Track { 39 39 + fn into(self) -> rockbox_search::rockbox::search::v1alpha1::Track { 40 40 + rockbox_search::rockbox::search::v1alpha1::Track { 41 41 + id: self.id, 42 42 + path: self.path, 43 43 + title: self.title, 44 44 + artist: self.artist, 45 45 + album: self.album, 46 46 + album_artist: self.album_artist, 47 47 + bitrate: self.bitrate, 48 48 + composer: self.composer, 49 49 + disc_number: self.disc_number, 50 50 + filesize: self.filesize, 51 51 + frequency: self.frequency, 52 52 + length: self.length, 53 53 + track_number: self.track_number.unwrap_or_default(), 54 54 + year: self.year.unwrap_or_default(), 55 55 + year_string: self.year_string.unwrap_or_default(), 56 56 + genre: self.genre.unwrap_or_default(), 57 57 + md5: self.md5, 58 58 + album_art: self.album_art, 59 59 + artist_id: Some(self.artist_id), 60 60 + album_id: Some(self.album_id), 61 61 + genre_id: Some(self.genre_id), 62 62 + created_at: self.created_at.to_rfc3339(), 63 63 + updated_at: self.updated_at.to_rfc3339(), 64 64 + } 65 65 + } 66 66 + } 67 67 + 68 68 + impl Into<rockbox_search::rockbox::search::v1alpha1::LikedTrack> for Track { 69 69 + fn into(self) -> rockbox_search::rockbox::search::v1alpha1::LikedTrack { 70 70 + rockbox_search::rockbox::search::v1alpha1::LikedTrack { 71 71 + id: self.id, 72 72 + path: self.path, 73 73 + title: self.title, 74 74 + artist: self.artist, 75 75 + album: self.album, 76 76 + album_artist: self.album_artist, 77 77 + bitrate: self.bitrate, 78 78 + composer: self.composer, 79 79 + disc_number: self.disc_number, 80 80 + filesize: self.filesize, 81 81 + frequency: self.frequency, 82 82 + length: self.length, 83 83 + track_number: self.track_number.unwrap_or_default(), 84 84 + year: self.year.unwrap_or_default(), 85 85 + year_string: self.year_string.unwrap_or_default(), 86 86 + genre: self.genre.unwrap_or_default(), 87 87 + md5: self.md5, 88 88 + album_art: self.album_art, 89 89 + artist_id: Some(self.artist_id), 90 90 + album_id: Some(self.album_id), 91 91 + genre_id: Some(self.genre_id), 92 92 + created_at: self.created_at.to_rfc3339(), 93 93 + updated_at: self.updated_at.to_rfc3339(), 94 94 + } 95 95 + } 96 96 + }

+2

crates/rpc/Cargo.toml

··· 12 12 prost = "0.13.2" 13 13 reqwest = {version = "0.12.7", features = ["rustls-tls", "json"], default-features = false} 14 14 rockbox-library = {path = "../library"} 15 15 + rockbox-search = {path = "../search"} 15 16 rockbox-sys = {path = "../sys"} 17 17 + rockbox-types = {path = "../types"} 16 18 serde = {version = "1.0.210", features = ["derive"]} 17 19 serde_json = "1.0.128" 18 20 sqlx = {version = "0.8.2", features = ["runtime-tokio", "tls-rustls", "sqlite", "chrono", "derive", "macros"]}

+11

crates/rpc/proto/rockbox/v1alpha1/library.proto

··· 131 131 132 132 message ScanLibraryResponse {} 133 133 134 134 + message SearchRequest { 135 135 + string term = 1; 136 136 + } 137 137 + 138 138 + message SearchResponse { 139 139 + repeated Track tracks = 1; 140 140 + repeated Album albums = 2; 141 141 + repeated Artist artists = 3; 142 142 + } 143 143 + 134 144 service LibraryService { 135 145 rpc GetAlbums(GetAlbumsRequest) returns (GetAlbumsResponse); 136 146 rpc GetArtists(GetArtistsRequest) returns (GetArtistsResponse); ··· 145 155 rpc GetLikedTracks(GetLikedTracksRequest) returns (GetLikedTracksResponse); 146 156 rpc GetLikedAlbums(GetLikedAlbumsRequest) returns (GetLikedAlbumsResponse); 147 157 rpc ScanLibrary(ScanLibraryRequest) returns (ScanLibraryResponse); 158 158 + rpc Search(SearchRequest) returns (SearchResponse); 148 159 }

+85

crates/rpc/src/api/rockbox.v1alpha1.rs

··· 505 505 pub struct ScanLibraryRequest {} 506 506 #[derive(Clone, Copy, PartialEq, ::prost::Message)] 507 507 pub struct ScanLibraryResponse {} 508 508 + #[derive(Clone, PartialEq, ::prost::Message)] 509 509 + pub struct SearchRequest { 510 510 + #[prost(string, tag = "1")] 511 511 + pub term: ::prost::alloc::string::String, 512 512 + } 513 513 + #[derive(Clone, PartialEq, ::prost::Message)] 514 514 + pub struct SearchResponse { 515 515 + #[prost(message, repeated, tag = "1")] 516 516 + pub tracks: ::prost::alloc::vec::Vec<Track>, 517 517 + #[prost(message, repeated, tag = "2")] 518 518 + pub albums: ::prost::alloc::vec::Vec<Album>, 519 519 + #[prost(message, repeated, tag = "3")] 520 520 + pub artists: ::prost::alloc::vec::Vec<Artist>, 521 521 + } 508 522 /// Generated client implementations. 509 523 pub mod library_service_client { 510 524 #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] ··· 927 941 ); 928 942 self.inner.unary(req, path, codec).await 929 943 } 944 944 + pub async fn search( 945 945 + &mut self, 946 946 + request: impl tonic::IntoRequest<super::SearchRequest>, 947 947 + ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> { 948 948 + self.inner 949 949 + .ready() 950 950 + .await 951 951 + .map_err(|e| { 952 952 + tonic::Status::new( 953 953 + tonic::Code::Unknown, 954 954 + format!("Service was not ready: {}", e.into()), 955 955 + ) 956 956 + })?; 957 957 + let codec = tonic::codec::ProstCodec::default(); 958 958 + let path = http::uri::PathAndQuery::from_static( 959 959 + "/rockbox.v1alpha1.LibraryService/Search", 960 960 + ); 961 961 + let mut req = request.into_request(); 962 962 + req.extensions_mut() 963 963 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "Search")); 964 964 + self.inner.unary(req, path, codec).await 965 965 + } 930 966 } 931 967 } 932 968 /// Generated server implementations. ··· 1027 1063 tonic::Response<super::ScanLibraryResponse>, 1028 1064 tonic::Status, 1029 1065 >; 1066 1066 + async fn search( 1067 1067 + &self, 1068 1068 + request: tonic::Request<super::SearchRequest>, 1069 1069 + ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status>; 1030 1070 } 1031 1071 #[derive(Debug)] 1032 1072 pub struct LibraryServiceServer<T> { ··· 1676 1716 let inner = self.inner.clone(); 1677 1717 let fut = async move { 1678 1718 let method = ScanLibrarySvc(inner); 1719 1719 + let codec = tonic::codec::ProstCodec::default(); 1720 1720 + let mut grpc = tonic::server::Grpc::new(codec) 1721 1721 + .apply_compression_config( 1722 1722 + accept_compression_encodings, 1723 1723 + send_compression_encodings, 1724 1724 + ) 1725 1725 + .apply_max_message_size_config( 1726 1726 + max_decoding_message_size, 1727 1727 + max_encoding_message_size, 1728 1728 + ); 1729 1729 + let res = grpc.unary(method, req).await; 1730 1730 + Ok(res) 1731 1731 + }; 1732 1732 + Box::pin(fut) 1733 1733 + } 1734 1734 + "/rockbox.v1alpha1.LibraryService/Search" => { 1735 1735 + #[allow(non_camel_case_types)] 1736 1736 + struct SearchSvc<T: LibraryService>(pub Arc<T>); 1737 1737 + impl< 1738 1738 + T: LibraryService, 1739 1739 + > tonic::server::UnaryService<super::SearchRequest> 1740 1740 + for SearchSvc<T> { 1741 1741 + type Response = super::SearchResponse; 1742 1742 + type Future = BoxFuture< 1743 1743 + tonic::Response<Self::Response>, 1744 1744 + tonic::Status, 1745 1745 + >; 1746 1746 + fn call( 1747 1747 + &mut self, 1748 1748 + request: tonic::Request<super::SearchRequest>, 1749 1749 + ) -> Self::Future { 1750 1750 + let inner = Arc::clone(&self.0); 1751 1751 + let fut = async move { 1752 1752 + <T as LibraryService>::search(&inner, request).await 1753 1753 + }; 1754 1754 + Box::pin(fut) 1755 1755 + } 1756 1756 + } 1757 1757 + let accept_compression_encodings = self.accept_compression_encodings; 1758 1758 + let send_compression_encodings = self.send_compression_encodings; 1759 1759 + let max_decoding_message_size = self.max_decoding_message_size; 1760 1760 + let max_encoding_message_size = self.max_encoding_message_size; 1761 1761 + let inner = self.inner.clone(); 1762 1762 + let fut = async move { 1763 1763 + let method = SearchSvc(inner); 1679 1764 let codec = tonic::codec::ProstCodec::default(); 1680 1765 let mut grpc = tonic::server::Grpc::new(codec) 1681 1766 .apply_compression_config(

crates/rpc/src/api/rockbox_descriptor.bin

This is a binary file and will not be displayed.

+69 -1

crates/rpc/src/lib.rs

··· 28 28 }; 29 29 use v1alpha1::{ 30 30 Album, Artist, CurrentTrackResponse, Entry, GetGlobalSettingsResponse, 31 31 - GetGlobalStatusResponse, NextTrackResponse, Track, 31 31 + GetGlobalStatusResponse, NextTrackResponse, SearchResponse, Track, 32 32 }; 33 33 34 34 #[path = "rockbox.v1alpha1.rs"] ··· 719 719 genre_id: Some(track.genre_id), 720 720 created_at: track.created_at.to_rfc3339(), 721 721 updated_at: track.updated_at.to_rfc3339(), 722 722 + } 723 723 + } 724 724 + } 725 725 + 726 726 + impl From<rockbox_search::rockbox::search::v1alpha1::Album> for Album { 727 727 + fn from(album: rockbox_search::rockbox::search::v1alpha1::Album) -> Self { 728 728 + Self { 729 729 + id: album.id, 730 730 + title: album.title, 731 731 + artist: album.artist, 732 732 + year: album.year, 733 733 + year_string: album.year_string, 734 734 + album_art: album.album_art, 735 735 + md5: album.md5, 736 736 + artist_id: album.artist_id, 737 737 + ..Default::default() 738 738 + } 739 739 + } 740 740 + } 741 741 + 742 742 + impl From<rockbox_search::rockbox::search::v1alpha1::Artist> for Artist { 743 743 + fn from(artist: rockbox_search::rockbox::search::v1alpha1::Artist) -> Self { 744 744 + Self { 745 745 + id: artist.id, 746 746 + name: artist.name, 747 747 + bio: artist.bio, 748 748 + image: artist.image, 749 749 + ..Default::default() 750 750 + } 751 751 + } 752 752 + } 753 753 + 754 754 + impl From<rockbox_search::rockbox::search::v1alpha1::Track> for Track { 755 755 + fn from(track: rockbox_search::rockbox::search::v1alpha1::Track) -> Self { 756 756 + Self { 757 757 + id: track.id, 758 758 + path: track.path, 759 759 + title: track.title, 760 760 + artist: track.artist, 761 761 + album: track.album, 762 762 + album_artist: track.album_artist, 763 763 + bitrate: track.bitrate, 764 764 + composer: track.composer, 765 765 + disc_number: track.disc_number, 766 766 + filesize: track.filesize, 767 767 + frequency: track.frequency, 768 768 + length: track.length, 769 769 + track_number: track.track_number, 770 770 + year: track.year, 771 771 + year_string: track.year_string, 772 772 + genre: track.genre, 773 773 + md5: track.md5, 774 774 + album_art: track.album_art, 775 775 + artist_id: track.artist_id, 776 776 + album_id: track.album_id, 777 777 + genre_id: track.genre_id, 778 778 + created_at: track.created_at, 779 779 + updated_at: track.updated_at, 780 780 + } 781 781 + } 782 782 + } 783 783 + 784 784 + impl From<rockbox_types::SearchResults> for SearchResponse { 785 785 + fn from(results: rockbox_types::SearchResults) -> Self { 786 786 + Self { 787 787 + artists: results.artists.into_iter().map(Into::into).collect(), 788 788 + albums: results.albums.into_iter().map(Into::into).collect(), 789 789 + tracks: results.tracks.into_iter().map(Into::into).collect(), 722 790 } 723 791 } 724 792 }

+40 -17

crates/rpc/src/library.rs

··· 1 1 - use std::env; 2 2 - 3 3 - use rockbox_library::{audio_scan::scan_audio_files, entity::favourites::Favourites, repo}; 1 1 + use rockbox_library::{entity::favourites::Favourites, repo}; 2 2 + use rockbox_types::SearchResults; 4 3 use sqlx::Sqlite; 5 4 6 6 - use crate::api::rockbox::v1alpha1::{ 7 7 - library_service_server::LibraryService, Album, Artist, GetAlbumRequest, GetAlbumResponse, 8 8 - GetAlbumsRequest, GetAlbumsResponse, GetArtistRequest, GetArtistResponse, GetArtistsRequest, 9 9 - GetArtistsResponse, GetLikedAlbumsRequest, GetLikedAlbumsResponse, GetLikedTracksRequest, 10 10 - GetLikedTracksResponse, GetTrackRequest, GetTrackResponse, GetTracksRequest, GetTracksResponse, 11 11 - LikeAlbumRequest, LikeAlbumResponse, LikeTrackRequest, LikeTrackResponse, ScanLibraryRequest, 12 12 - ScanLibraryResponse, UnlikeAlbumRequest, UnlikeAlbumResponse, UnlikeTrackRequest, 13 13 - UnlikeTrackResponse, 5 5 + use crate::{ 6 6 + api::rockbox::v1alpha1::{ 7 7 + library_service_server::LibraryService, Album, Artist, GetAlbumRequest, GetAlbumResponse, 8 8 + GetAlbumsRequest, GetAlbumsResponse, GetArtistRequest, GetArtistResponse, 9 9 + GetArtistsRequest, GetArtistsResponse, GetLikedAlbumsRequest, GetLikedAlbumsResponse, 10 10 + GetLikedTracksRequest, GetLikedTracksResponse, GetTrackRequest, GetTrackResponse, 11 11 + GetTracksRequest, GetTracksResponse, LikeAlbumRequest, LikeAlbumResponse, LikeTrackRequest, 12 12 + LikeTrackResponse, ScanLibraryRequest, ScanLibraryResponse, SearchRequest, SearchResponse, 13 13 + UnlikeAlbumRequest, UnlikeAlbumResponse, UnlikeTrackRequest, UnlikeTrackResponse, 14 14 + }, 15 15 + rockbox_url, 14 16 }; 15 17 16 18 pub struct Library { 17 19 pool: sqlx::Pool<Sqlite>, 20 20 + client: reqwest::Client, 18 21 } 19 22 20 23 impl Library { 21 21 - pub fn new(pool: sqlx::Pool<Sqlite>) -> Self { 22 22 - Self { pool } 24 24 + pub fn new(pool: sqlx::Pool<Sqlite>, client: reqwest::Client) -> Self { 25 25 + Self { pool, client } 23 26 } 24 27 } 25 28 ··· 207 210 &self, 208 211 _request: tonic::Request<ScanLibraryRequest>, 209 212 ) -> Result<tonic::Response<ScanLibraryResponse>, tonic::Status> { 210 210 - let home = env::var("HOME").map_err(|e| tonic::Status::internal(e.to_string()))?; 211 211 - let path = env::var("ROCKBOX_LIBRARY").unwrap_or(format!("{}/Music", home)); 213 213 + let url = format!("{}/scan-library", rockbox_url()); 214 214 + self.client 215 215 + .put(&url) 216 216 + .send() 217 217 + .await 218 218 + .map_err(|e| tonic::Status::internal(e.to_string()))?; 219 219 + Ok(tonic::Response::new(ScanLibraryResponse {})) 220 220 + } 212 221 213 213 - scan_audio_files(self.pool.clone(), path.into()) 222 222 + async fn search( 223 223 + &self, 224 224 + request: tonic::Request<SearchRequest>, 225 225 + ) -> Result<tonic::Response<SearchResponse>, tonic::Status> { 226 226 + let request = request.into_inner(); 227 227 + let term = request.term; 228 228 + let url = format!("{}/search?q={}", rockbox_url(), term); 229 229 + let response = self 230 230 + .client 231 231 + .get(&url) 232 232 + .send() 233 233 + .await 234 234 + .map_err(|e| tonic::Status::internal(e.to_string()))?; 235 235 + let results = response 236 236 + .json::<SearchResults>() 214 237 .await 215 238 .map_err(|e| tonic::Status::internal(e.to_string()))?; 216 239 217 217 - Ok(tonic::Response::new(ScanLibraryResponse {})) 240 240 + Ok(tonic::Response::new(results.into())) 218 241 } 219 242 }

+1

crates/rpc/src/server.rs

··· 42 42 ) 43 43 .add_service(tonic_web::enable(LibraryServiceServer::new(Library::new( 44 44 pool.clone(), 45 45 + client.clone(), 45 46 )))) 46 47 .add_service(tonic_web::enable(PlaylistServiceServer::new( 47 48 Playlist::new(cmd_tx.clone(), client.clone(), pool.clone()),

+17

crates/search/Cargo.toml

··· 1 1 + [package] 2 2 + edition = "2021" 3 3 + name = "rockbox-search" 4 4 + version = "0.1.0" 5 5 + 6 6 + [dependencies] 7 7 + anyhow = "1.0.90" 8 8 + prost = "0.13.3" 9 9 + prost-helper = "0.8.3" 10 10 + prost-types = "0.13.3" 11 11 + serde = {version = "1.0.213", features = ["derive"]} 12 12 + 13 13 + [build-dependencies] 14 14 + prost-build = "0.13.3" 15 15 + prost-serde = "0.3.0" 16 16 + serde = {version = "1.0.213", features = ["derive"]} 17 17 + serde_yaml = "0.9.34"

+148

crates/search/build.rs

··· 1 1 + use prost_build::{Config, Service, ServiceGenerator}; 2 2 + use serde::{Deserialize, Serialize}; 3 3 + use std::io::Result; 4 4 + use std::{fs, path::PathBuf, process::Command}; 5 5 + 6 6 + #[derive(Deserialize, Serialize, Debug, Default)] 7 7 + #[serde(default)] 8 8 + pub struct BuildConfig { 9 9 + /// base path for protobuf files 10 10 + pub base_path: Option<PathBuf>, 11 11 + /// protobuf include dirs 12 12 + pub includes: Vec<String>, 13 13 + /// protobuf files 14 14 + pub files: Vec<String>, 15 15 + /// dir for generated code, defaults to Cargo OUT_DIR, else the current dir 16 16 + pub output: Option<String>, 17 17 + /// build options for messages 18 18 + pub messages: Vec<BuildOption>, 19 19 + /// build options for enums 20 20 + pub enums: Vec<BuildOption>, 21 21 + /// build options for fields 22 22 + pub fields: Vec<BuildOption>, 23 23 + /// build options for bytes 24 24 + pub bytes: Vec<String>, 25 25 + /// build options for BTreeMap 26 26 + pub btree_maps: Vec<String>, 27 27 + } 28 28 + 29 29 + #[derive(Deserialize, Serialize, Debug, Default)] 30 30 + #[serde(default)] 31 31 + pub struct BuildOption { 32 32 + /// a list of paths you want to add the attribute 33 33 + pub paths: Vec<String>, 34 34 + /// description of the option 35 35 + pub description: String, 36 36 + /// extra attributes to put on generated data structure, for example: `derive(Serialize, Deserialize)` 37 37 + /// it will be converted to `#[derive(Serialize, Deserialize)]` 38 38 + pub attrs: Vec<String>, 39 39 + } 40 40 + 41 41 + impl From<BuildConfig> for Builder { 42 42 + fn from(config: BuildConfig) -> Self { 43 43 + // For the output directory, use the specified one, or fallback to the 44 44 + // OUT_DIR env variable provided by Cargo if it exists (it should!), else 45 45 + // fallback to the current directory. 46 46 + let output_dir: String = match &config.output { 47 47 + None => { 48 48 + let default_output_dir = std::env::var("OUT_DIR"); 49 49 + 50 50 + match default_output_dir { 51 51 + Err(_) => String::new(), 52 52 + Ok(cargo_out_dir) => cargo_out_dir, 53 53 + } 54 54 + } 55 55 + Some(specified_output) => specified_output.to_owned(), 56 56 + }; 57 57 + 58 58 + let mut c = Config::new(); 59 59 + 60 60 + c.btree_map(config.btree_maps); 61 61 + c.bytes(config.bytes); 62 62 + 63 63 + for opt in config.messages { 64 64 + for p in opt.paths { 65 65 + c.type_attribute(p, to_attr(&opt.attrs)); 66 66 + } 67 67 + } 68 68 + 69 69 + for opt in config.enums { 70 70 + for p in opt.paths { 71 71 + c.type_attribute(p, to_attr(&opt.attrs)); 72 72 + } 73 73 + } 74 74 + 75 75 + for opt in config.fields { 76 76 + for p in opt.paths { 77 77 + c.field_attribute(p, to_attr(&opt.attrs)); 78 78 + } 79 79 + } 80 80 + 81 81 + fs::create_dir_all(&output_dir).unwrap(); 82 82 + c.out_dir(&output_dir); 83 83 + 84 84 + let f = |v: String| match config.base_path { 85 85 + Some(ref base_path) => base_path.join(v).to_string_lossy().to_string(), 86 86 + None => v, 87 87 + }; 88 88 + Self { 89 89 + config: c, 90 90 + includes: config.includes.into_iter().map(f).collect(), 91 91 + files: config.files.into_iter().map(f).collect(), 92 92 + } 93 93 + } 94 94 + } 95 95 + 96 96 + pub struct Builder { 97 97 + /// prost configuration 98 98 + config: Config, 99 99 + /// protobuf include dirs 100 100 + pub includes: Vec<String>, 101 101 + /// protobuf files 102 102 + pub files: Vec<String>, 103 103 + } 104 104 + 105 105 + impl Builder { 106 106 + /// Configures the code generator for service generator 107 107 + pub fn service_generator(&mut self, service_generator: Box<dyn ServiceGenerator>) -> &mut Self { 108 108 + self.config.service_generator(service_generator); 109 109 + self 110 110 + } 111 111 + 112 112 + /// build protobuf with configuration 113 113 + pub fn build_protos(&mut self) { 114 114 + self.config 115 115 + .compile_protos(&self.files, &self.includes) 116 116 + .unwrap_or_else(|e| panic!("Failed to compile proto files. Err: {:?}", e)); 117 117 + 118 118 + Command::new("cargo") 119 119 + .args(["fmt"]) 120 120 + .status() 121 121 + .expect("cargo fmt failed"); 122 122 + } 123 123 + } 124 124 + 125 125 + fn to_attr(attrs: &[String]) -> String { 126 126 + attrs 127 127 + .iter() 128 128 + .map(|s| format!("#[{}]", s)) 129 129 + .collect::<Vec<_>>() 130 130 + .join("\n") 131 131 + } 132 132 + 133 133 + struct MyServiceGen; 134 134 + 135 135 + impl ServiceGenerator for MyServiceGen { 136 136 + fn generate(&mut self, service: Service, _buf: &mut String) { 137 137 + println!("{service:#?}"); 138 138 + } 139 139 + } 140 140 + 141 141 + fn main() -> Result<()> { 142 142 + let content = include_str!("./build_config.yml"); 143 143 + let config: BuildConfig = serde_yaml::from_str(content).unwrap(); 144 144 + Builder::from(config) 145 145 + .service_generator(Box::new(MyServiceGen)) 146 146 + .build_protos(); 147 147 + Ok(()) 148 148 + }

+36

crates/search/build_config.yml

··· 1 1 + --- 2 2 + includes: [src/proto] 3 3 + files: 4 4 + - src/proto/rockbox/search/v1alpha1/album.proto 5 5 + - src/proto/rockbox/search/v1alpha1/artist.proto 6 6 + - src/proto/rockbox/search/v1alpha1/file.proto 7 7 + - src/proto/rockbox/search/v1alpha1/like.proto 8 8 + - src/proto/rockbox/search/v1alpha1/track.proto 9 9 + output: src/pb 10 10 + messages: 11 11 + - paths: 12 12 + - rockbox.search.v1alpha1.Album 13 13 + - rockbox.search.v1alpha1.AlbumList 14 14 + - rockbox.search.v1alpha1.Artist 15 15 + - rockbox.search.v1alpha1.ArtistList 16 16 + - rockbox.search.v1alpha1.File 17 17 + - rockbox.search.v1alpha1.FileList 18 18 + - rockbox.search.v1alpha1.LikedTrack 19 19 + - rockbox.search.v1alpha1.LikedTrackList 20 20 + - rockbox.search.v1alpha1.LikedAlbum 21 21 + - rockbox.search.v1alpha1.LikedAlbumList 22 22 + - rockbox.search.v1alpha1.Track 23 23 + - rockbox.search.v1alpha1.TrackList 24 24 + attrs: 25 25 + - derive(serde::Serialize, serde::Deserialize) 26 26 + - serde(default) 27 27 + enums: 28 28 + - paths: [] 29 29 + attrs: 30 30 + - derive(serde::Serialize, serde::Deserialize) 31 31 + - serde(rename_all = "lowercase") 32 32 + fields: 33 33 + - paths: [] 34 34 + attrs: 35 35 + btree_map: ["."] 36 36 + bytes: ["."]

+190

crates/search/src/lib.rs

··· 1 1 + pub mod rockbox { 2 2 + pub mod search { 3 3 + pub mod v1alpha1 { 4 4 + include!("./pb/rockbox.search.v1alpha1.rs"); 5 5 + } 6 6 + } 7 7 + } 8 8 + 9 9 + use anyhow::Error; 10 10 + use prost::Message; 11 11 + use std::ffi::CString; 12 12 + 13 13 + use rockbox::search::v1alpha1::*; 14 14 + 15 15 + extern "C" { 16 16 + fn IndexAlbum(data: *const u8, size: i32); 17 17 + fn IndexArtist(data: *const u8, size: i32); 18 18 + fn IndexFile(data: *const u8, size: i32); 19 19 + fn IndexLikedTrack(data: *const u8, size: i32); 20 20 + fn IndexLikedAlbum(data: *const u8, size: i32); 21 21 + fn IndexTrack(data: *const u8, size: i32); 22 22 + fn IndexAlbums(data: *const u8, size: i32); 23 23 + fn IndexArtists(data: *const u8, size: i32); 24 24 + fn IndexFiles(data: *const u8, size: i32); 25 25 + fn IndexLikedTracks(data: *const u8, size: i32); 26 26 + fn IndexLikedAlbums(data: *const u8, size: i32); 27 27 + fn IndexTracks(data: *const u8, size: i32); 28 28 + fn SearchAlbum(term: *const u8) -> *const u8; 29 29 + fn SearchArtist(term: *const u8) -> *const u8; 30 30 + fn SearchFile(term: *const u8) -> *const u8; 31 31 + fn SearchTrack(term: *const u8) -> *const u8; 32 32 + fn SearchLikedTrack(term: *const u8) -> *const u8; 33 33 + fn SearchLikedAlbum(term: *const u8) -> *const u8; 34 34 + } 35 35 + 36 36 + pub fn index_album(album: Album) -> Result<(), Error> { 37 37 + let mut buf = Vec::new(); 38 38 + album.encode(&mut buf)?; 39 39 + unsafe { 40 40 + IndexAlbum(buf.as_ptr() as *const u8, buf.len() as i32); 41 41 + } 42 42 + Ok(()) 43 43 + } 44 44 + 45 45 + pub fn index_artist(artist: Artist) -> Result<(), Error> { 46 46 + let mut buf = Vec::new(); 47 47 + artist.encode(&mut buf)?; 48 48 + unsafe { 49 49 + IndexArtist(buf.as_ptr() as *const u8, buf.len() as i32); 50 50 + } 51 51 + Ok(()) 52 52 + } 53 53 + 54 54 + pub fn index_file(file: File) -> Result<(), Error> { 55 55 + let mut buf = Vec::new(); 56 56 + file.encode(&mut buf)?; 57 57 + unsafe { 58 58 + IndexFile(buf.as_ptr() as *const u8, buf.len() as i32); 59 59 + } 60 60 + Ok(()) 61 61 + } 62 62 + 63 63 + pub fn index_liked_track(liked_track: LikedTrack) -> Result<(), Error> { 64 64 + let mut buf = Vec::new(); 65 65 + liked_track.encode(&mut buf)?; 66 66 + unsafe { 67 67 + IndexLikedTrack(buf.as_ptr() as *const u8, buf.len() as i32); 68 68 + } 69 69 + Ok(()) 70 70 + } 71 71 + 72 72 + pub fn index_liked_album(liked_album: LikedAlbum) -> Result<(), Error> { 73 73 + let mut buf = Vec::new(); 74 74 + liked_album.encode(&mut buf)?; 75 75 + unsafe { 76 76 + IndexLikedAlbum(buf.as_ptr() as *const u8, buf.len() as i32); 77 77 + } 78 78 + Ok(()) 79 79 + } 80 80 + 81 81 + pub fn index_track(track: Track) -> Result<(), Error> { 82 82 + let mut buf = Vec::new(); 83 83 + track.encode(&mut buf)?; 84 84 + unsafe { 85 85 + IndexTrack(buf.as_ptr() as *const u8, buf.len() as i32); 86 86 + } 87 87 + Ok(()) 88 88 + } 89 89 + 90 90 + pub fn index_albums(albums: AlbumList) -> Result<(), Error> { 91 91 + let mut buf = Vec::new(); 92 92 + albums.encode(&mut buf)?; 93 93 + unsafe { 94 94 + IndexAlbums(buf.as_ptr() as *const u8, buf.len() as i32); 95 95 + } 96 96 + Ok(()) 97 97 + } 98 98 + 99 99 + pub fn index_artists(artists: ArtistList) -> Result<(), Error> { 100 100 + let mut buf = Vec::new(); 101 101 + artists.encode(&mut buf)?; 102 102 + unsafe { 103 103 + IndexArtists(buf.as_ptr() as *const u8, buf.len() as i32); 104 104 + } 105 105 + Ok(()) 106 106 + } 107 107 + 108 108 + pub fn index_files(files: FileList) -> Result<(), Error> { 109 109 + let mut buf = Vec::new(); 110 110 + files.encode(&mut buf)?; 111 111 + unsafe { 112 112 + IndexFiles(buf.as_ptr() as *const u8, buf.len() as i32); 113 113 + } 114 114 + Ok(()) 115 115 + } 116 116 + 117 117 + pub fn index_liked_tracks(liked_tracks: LikedTrackList) -> Result<(), Error> { 118 118 + let mut buf = Vec::new(); 119 119 + liked_tracks.encode(&mut buf)?; 120 120 + unsafe { 121 121 + IndexLikedTracks(buf.as_ptr() as *const u8, buf.len() as i32); 122 122 + } 123 123 + Ok(()) 124 124 + } 125 125 + 126 126 + pub fn index_liked_albums(liked_albums: LikedAlbumList) -> Result<(), Error> { 127 127 + let mut buf = Vec::new(); 128 128 + liked_albums.encode(&mut buf)?; 129 129 + unsafe { 130 130 + IndexLikedAlbums(buf.as_ptr() as *const u8, buf.len() as i32); 131 131 + } 132 132 + Ok(()) 133 133 + } 134 134 + 135 135 + pub fn index_tracks(tracks: TrackList) -> Result<(), Error> { 136 136 + let mut buf = Vec::new(); 137 137 + tracks.encode(&mut buf)?; 138 138 + unsafe { 139 139 + IndexTracks(buf.as_ptr() as *const u8, buf.len() as i32); 140 140 + } 141 141 + Ok(()) 142 142 + } 143 143 + 144 144 + pub fn search_album(term: &str) -> Result<AlbumList, Error> { 145 145 + let term = CString::new(term).unwrap(); 146 146 + let result = unsafe { SearchAlbum(term.as_ptr() as *const u8) }; 147 147 + let result = unsafe { CString::from_raw(result as *mut i8) }; 148 148 + let albums = AlbumList::decode(result.as_bytes())?; 149 149 + Ok(albums) 150 150 + } 151 151 + 152 152 + pub fn search_artist(term: &str) -> Result<ArtistList, Error> { 153 153 + let term = CString::new(term).unwrap(); 154 154 + let result = unsafe { SearchArtist(term.as_ptr() as *const u8) }; 155 155 + let result = unsafe { CString::from_raw(result as *mut i8) }; 156 156 + let artists = ArtistList::decode(result.as_bytes())?; 157 157 + Ok(artists) 158 158 + } 159 159 + 160 160 + pub fn search_file(term: &str) -> Result<FileList, Error> { 161 161 + let term = CString::new(term).unwrap(); 162 162 + let result = unsafe { SearchFile(term.as_ptr() as *const u8) }; 163 163 + let result = unsafe { CString::from_raw(result as *mut i8) }; 164 164 + let files = FileList::decode(result.as_bytes())?; 165 165 + Ok(files) 166 166 + } 167 167 + 168 168 + pub fn search_track(term: &str) -> Result<TrackList, Error> { 169 169 + let term = CString::new(term).unwrap(); 170 170 + let result = unsafe { SearchTrack(term.as_ptr() as *const u8) }; 171 171 + let result = unsafe { CString::from_raw(result as *mut i8) }; 172 172 + let tracks = TrackList::decode(result.as_bytes())?; 173 173 + Ok(tracks) 174 174 + } 175 175 + 176 176 + pub fn search_liked_track(term: &str) -> Result<LikedTrackList, Error> { 177 177 + let term = CString::new(term).unwrap(); 178 178 + let result = unsafe { SearchLikedTrack(term.as_ptr() as *const u8) }; 179 179 + let result = unsafe { CString::from_raw(result as *mut i8) }; 180 180 + let liked_tracks = LikedTrackList::decode(result.as_bytes())?; 181 181 + Ok(liked_tracks) 182 182 + } 183 183 + 184 184 + pub fn search_liked_album(term: &str) -> Result<LikedAlbumList, Error> { 185 185 + let term = CString::new(term).unwrap(); 186 186 + let result = unsafe { SearchLikedAlbum(term.as_ptr() as *const u8) }; 187 187 + let result = unsafe { CString::from_raw(result as *mut i8) }; 188 188 + let liked_albums = LikedAlbumList::decode(result.as_bytes())?; 189 189 + Ok(liked_albums) 190 190 + }

+213

crates/search/src/pb/rockbox.search.v1alpha1.rs

··· 1 1 + // This file is @generated by prost-build. 2 2 + #[derive(serde::Serialize, serde::Deserialize)] 3 3 + #[serde(default)] 4 4 + #[derive(Clone, PartialEq, ::prost::Message)] 5 5 + pub struct Album { 6 6 + #[prost(string, tag = "1")] 7 7 + pub id: ::prost::alloc::string::String, 8 8 + #[prost(string, tag = "2")] 9 9 + pub title: ::prost::alloc::string::String, 10 10 + #[prost(string, tag = "3")] 11 11 + pub artist: ::prost::alloc::string::String, 12 12 + #[prost(uint32, tag = "4")] 13 13 + pub year: u32, 14 14 + #[prost(string, tag = "5")] 15 15 + pub year_string: ::prost::alloc::string::String, 16 16 + #[prost(string, optional, tag = "6")] 17 17 + pub album_art: ::core::option::Option<::prost::alloc::string::String>, 18 18 + #[prost(string, tag = "7")] 19 19 + pub md5: ::prost::alloc::string::String, 20 20 + #[prost(string, tag = "8")] 21 21 + pub artist_id: ::prost::alloc::string::String, 22 22 + } 23 23 + #[derive(serde::Serialize, serde::Deserialize)] 24 24 + #[serde(default)] 25 25 + #[derive(Clone, PartialEq, ::prost::Message)] 26 26 + pub struct AlbumList { 27 27 + #[prost(message, repeated, tag = "1")] 28 28 + pub albums: ::prost::alloc::vec::Vec<Album>, 29 29 + } 30 30 + #[derive(serde::Serialize, serde::Deserialize)] 31 31 + #[serde(default)] 32 32 + #[derive(Clone, PartialEq, ::prost::Message)] 33 33 + pub struct Artist { 34 34 + #[prost(string, tag = "1")] 35 35 + pub id: ::prost::alloc::string::String, 36 36 + #[prost(string, tag = "2")] 37 37 + pub name: ::prost::alloc::string::String, 38 38 + #[prost(string, optional, tag = "3")] 39 39 + pub bio: ::core::option::Option<::prost::alloc::string::String>, 40 40 + #[prost(string, optional, tag = "4")] 41 41 + pub image: ::core::option::Option<::prost::alloc::string::String>, 42 42 + } 43 43 + #[derive(serde::Serialize, serde::Deserialize)] 44 44 + #[serde(default)] 45 45 + #[derive(Clone, PartialEq, ::prost::Message)] 46 46 + pub struct ArtistList { 47 47 + #[prost(message, repeated, tag = "1")] 48 48 + pub artists: ::prost::alloc::vec::Vec<Artist>, 49 49 + } 50 50 + #[derive(serde::Serialize, serde::Deserialize)] 51 51 + #[serde(default)] 52 52 + #[derive(Clone, PartialEq, ::prost::Message)] 53 53 + pub struct File { 54 54 + #[prost(string, tag = "1")] 55 55 + pub id: ::prost::alloc::string::String, 56 56 + #[prost(string, tag = "2")] 57 57 + pub name: ::prost::alloc::string::String, 58 58 + #[prost(uint32, tag = "4")] 59 59 + pub time_write: u32, 60 60 + #[prost(bool, tag = "5")] 61 61 + pub is_directory: bool, 62 62 + } 63 63 + #[derive(serde::Serialize, serde::Deserialize)] 64 64 + #[serde(default)] 65 65 + #[derive(Clone, PartialEq, ::prost::Message)] 66 66 + pub struct FileList { 67 67 + #[prost(message, repeated, tag = "1")] 68 68 + pub files: ::prost::alloc::vec::Vec<File>, 69 69 + } 70 70 + #[derive(serde::Serialize, serde::Deserialize)] 71 71 + #[serde(default)] 72 72 + #[derive(Clone, PartialEq, ::prost::Message)] 73 73 + pub struct LikedAlbum { 74 74 + #[prost(string, tag = "1")] 75 75 + pub id: ::prost::alloc::string::String, 76 76 + #[prost(string, tag = "2")] 77 77 + pub title: ::prost::alloc::string::String, 78 78 + #[prost(string, tag = "3")] 79 79 + pub artist: ::prost::alloc::string::String, 80 80 + #[prost(uint32, tag = "4")] 81 81 + pub year: u32, 82 82 + #[prost(string, tag = "5")] 83 83 + pub year_string: ::prost::alloc::string::String, 84 84 + #[prost(string, optional, tag = "6")] 85 85 + pub album_art: ::core::option::Option<::prost::alloc::string::String>, 86 86 + #[prost(string, tag = "7")] 87 87 + pub md5: ::prost::alloc::string::String, 88 88 + #[prost(string, tag = "8")] 89 89 + pub artist_id: ::prost::alloc::string::String, 90 90 + } 91 91 + #[derive(serde::Serialize, serde::Deserialize)] 92 92 + #[serde(default)] 93 93 + #[derive(Clone, PartialEq, ::prost::Message)] 94 94 + pub struct LikedTrack { 95 95 + #[prost(string, tag = "1")] 96 96 + pub id: ::prost::alloc::string::String, 97 97 + #[prost(string, tag = "2")] 98 98 + pub path: ::prost::alloc::string::String, 99 99 + #[prost(string, tag = "3")] 100 100 + pub title: ::prost::alloc::string::String, 101 101 + #[prost(string, tag = "4")] 102 102 + pub artist: ::prost::alloc::string::String, 103 103 + #[prost(string, tag = "5")] 104 104 + pub album: ::prost::alloc::string::String, 105 105 + #[prost(string, tag = "6")] 106 106 + pub album_artist: ::prost::alloc::string::String, 107 107 + #[prost(uint32, tag = "7")] 108 108 + pub bitrate: u32, 109 109 + #[prost(string, tag = "8")] 110 110 + pub composer: ::prost::alloc::string::String, 111 111 + #[prost(uint32, tag = "9")] 112 112 + pub disc_number: u32, 113 113 + #[prost(uint32, tag = "10")] 114 114 + pub filesize: u32, 115 115 + #[prost(uint32, tag = "11")] 116 116 + pub frequency: u32, 117 117 + #[prost(uint32, tag = "12")] 118 118 + pub length: u32, 119 119 + #[prost(uint32, tag = "13")] 120 120 + pub track_number: u32, 121 121 + #[prost(uint32, tag = "14")] 122 122 + pub year: u32, 123 123 + #[prost(string, tag = "15")] 124 124 + pub year_string: ::prost::alloc::string::String, 125 125 + #[prost(string, tag = "16")] 126 126 + pub genre: ::prost::alloc::string::String, 127 127 + #[prost(string, tag = "17")] 128 128 + pub md5: ::prost::alloc::string::String, 129 129 + #[prost(string, optional, tag = "18")] 130 130 + pub album_art: ::core::option::Option<::prost::alloc::string::String>, 131 131 + #[prost(string, optional, tag = "19")] 132 132 + pub artist_id: ::core::option::Option<::prost::alloc::string::String>, 133 133 + #[prost(string, optional, tag = "20")] 134 134 + pub album_id: ::core::option::Option<::prost::alloc::string::String>, 135 135 + #[prost(string, optional, tag = "21")] 136 136 + pub genre_id: ::core::option::Option<::prost::alloc::string::String>, 137 137 + #[prost(string, tag = "22")] 138 138 + pub created_at: ::prost::alloc::string::String, 139 139 + #[prost(string, tag = "23")] 140 140 + pub updated_at: ::prost::alloc::string::String, 141 141 + } 142 142 + #[derive(serde::Serialize, serde::Deserialize)] 143 143 + #[serde(default)] 144 144 + #[derive(Clone, PartialEq, ::prost::Message)] 145 145 + pub struct LikedAlbumList { 146 146 + #[prost(message, repeated, tag = "1")] 147 147 + pub albums: ::prost::alloc::vec::Vec<LikedAlbum>, 148 148 + } 149 149 + #[derive(serde::Serialize, serde::Deserialize)] 150 150 + #[serde(default)] 151 151 + #[derive(Clone, PartialEq, ::prost::Message)] 152 152 + pub struct LikedTrackList { 153 153 + #[prost(message, repeated, tag = "1")] 154 154 + pub tracks: ::prost::alloc::vec::Vec<LikedTrack>, 155 155 + } 156 156 + #[derive(serde::Serialize, serde::Deserialize)] 157 157 + #[serde(default)] 158 158 + #[derive(Clone, PartialEq, ::prost::Message)] 159 159 + pub struct Track { 160 160 + #[prost(string, tag = "1")] 161 161 + pub id: ::prost::alloc::string::String, 162 162 + #[prost(string, tag = "2")] 163 163 + pub path: ::prost::alloc::string::String, 164 164 + #[prost(string, tag = "3")] 165 165 + pub title: ::prost::alloc::string::String, 166 166 + #[prost(string, tag = "4")] 167 167 + pub artist: ::prost::alloc::string::String, 168 168 + #[prost(string, tag = "5")] 169 169 + pub album: ::prost::alloc::string::String, 170 170 + #[prost(string, tag = "6")] 171 171 + pub album_artist: ::prost::alloc::string::String, 172 172 + #[prost(uint32, tag = "7")] 173 173 + pub bitrate: u32, 174 174 + #[prost(string, tag = "8")] 175 175 + pub composer: ::prost::alloc::string::String, 176 176 + #[prost(uint32, tag = "9")] 177 177 + pub disc_number: u32, 178 178 + #[prost(uint32, tag = "10")] 179 179 + pub filesize: u32, 180 180 + #[prost(uint32, tag = "11")] 181 181 + pub frequency: u32, 182 182 + #[prost(uint32, tag = "12")] 183 183 + pub length: u32, 184 184 + #[prost(uint32, tag = "13")] 185 185 + pub track_number: u32, 186 186 + #[prost(uint32, tag = "14")] 187 187 + pub year: u32, 188 188 + #[prost(string, tag = "15")] 189 189 + pub year_string: ::prost::alloc::string::String, 190 190 + #[prost(string, tag = "16")] 191 191 + pub genre: ::prost::alloc::string::String, 192 192 + #[prost(string, tag = "17")] 193 193 + pub md5: ::prost::alloc::string::String, 194 194 + #[prost(string, optional, tag = "18")] 195 195 + pub album_art: ::core::option::Option<::prost::alloc::string::String>, 196 196 + #[prost(string, optional, tag = "19")] 197 197 + pub artist_id: ::core::option::Option<::prost::alloc::string::String>, 198 198 + #[prost(string, optional, tag = "20")] 199 199 + pub album_id: ::core::option::Option<::prost::alloc::string::String>, 200 200 + #[prost(string, optional, tag = "21")] 201 201 + pub genre_id: ::core::option::Option<::prost::alloc::string::String>, 202 202 + #[prost(string, tag = "22")] 203 203 + pub created_at: ::prost::alloc::string::String, 204 204 + #[prost(string, tag = "23")] 205 205 + pub updated_at: ::prost::alloc::string::String, 206 206 + } 207 207 + #[derive(serde::Serialize, serde::Deserialize)] 208 208 + #[serde(default)] 209 209 + #[derive(Clone, PartialEq, ::prost::Message)] 210 210 + pub struct TrackList { 211 211 + #[prost(message, repeated, tag = "1")] 212 212 + pub tracks: ::prost::alloc::vec::Vec<Track>, 213 213 + }

+1

crates/search/src/proto

··· 1 1 + ../../../search/proto

+2

crates/server/Cargo.toml

··· 16 16 rockbox-graphql = {path = "../graphql"} 17 17 rockbox-library = {path = "../library"} 18 18 rockbox-rpc = {path = "../rpc"} 19 19 + rockbox-search = {path = "../search"} 19 20 rockbox-sys = {path = "../sys"} 21 21 + rockbox-types = {path = "../types"} 20 22 serde = {version = "1.0.210", features = ["derive"]} 21 23 serde_json = "1.0.128" 22 24 sqlx = {version = "0.8.2", features = ["runtime-tokio", "tls-rustls", "sqlite", "chrono", "derive", "macros"]}

+2

crates/server/src/handlers/mod.rs

··· 4 4 pub mod docs; 5 5 pub mod player; 6 6 pub mod playlists; 7 7 + pub mod search; 7 8 pub mod settings; 8 9 pub mod system; 9 10 pub mod tracks; ··· 64 65 async_handler!(settings, get_global_settings); 65 66 async_handler!(docs, get_openapi); 66 67 async_handler!(docs, index); 68 68 + async_handler!(search, search);

+2 -4

crates/server/src/handlers/player.rs

··· 1 1 - use crate::{ 2 2 - http::{Context, Request, Response}, 3 3 - types::NewVolume, 4 4 - }; 1 1 + use crate::http::{Context, Request, Response}; 5 2 use anyhow::Error; 6 3 use rockbox_sys as rb; 4 4 + use rockbox_types::NewVolume; 7 5 8 6 pub async fn play(_ctx: &Context, req: &Request, _res: &mut Response) -> Result<(), Error> { 9 7 let elapsed = match req.query_params.get("elapsed") {

+2 -4

crates/server/src/handlers/playlists.rs

··· 1 1 - use crate::{ 2 2 - http::{Context, Request, Response}, 3 3 - types::{DeleteTracks, InsertTracks, NewPlaylist, StatusCode}, 4 4 - }; 1 1 + use crate::http::{Context, Request, Response}; 5 2 use anyhow::Error; 6 3 use rand::seq::SliceRandom; 7 4 use rockbox_graphql::read_files; ··· 10 7 self as rb, types::playlist_amount::PlaylistAmount, PLAYLIST_INSERT_LAST, 11 8 PLAYLIST_INSERT_LAST_SHUFFLED, 12 9 }; 10 10 + use rockbox_types::{DeleteTracks, InsertTracks, NewPlaylist, StatusCode}; 13 11 14 12 pub async fn create_playlist( 15 13 _ctx: &Context,

+40

crates/server/src/handlers/search.rs

··· 1 1 + use crate::http::{Context, Request, Response}; 2 2 + use anyhow::Error; 3 3 + use rockbox_search::{ 4 4 + search_album, search_artist, search_file, search_liked_album, search_liked_track, search_track, 5 5 + }; 6 6 + use rockbox_types::SearchResults; 7 7 + 8 8 + pub async fn search(_ctx: &Context, req: &Request, res: &mut Response) -> Result<(), Error> { 9 9 + let term = req 10 10 + .query_params 11 11 + .get("q") 12 12 + .map(|t| t.as_str()) 13 13 + .unwrap_or_default(); 14 14 + 15 15 + match term { 16 16 + None => { 17 17 + res.json(&SearchResults::default()); 18 18 + } 19 19 + Some(term) => { 20 20 + let albums = search_album(term)?.albums; 21 21 + let artists = search_artist(term)?.artists; 22 22 + let tracks = search_track(term)?.tracks; 23 23 + let files = search_file(term)?.files; 24 24 + let liked_tracks = search_liked_track(term)?.tracks; 25 25 + let liked_albums = search_liked_album(term)?.albums; 26 26 + 27 27 + let results = SearchResults { 28 28 + albums, 29 29 + artists, 30 30 + tracks, 31 31 + files, 32 32 + liked_tracks, 33 33 + liked_albums, 34 34 + }; 35 35 + 36 36 + res.json(&results); 37 37 + } 38 38 + } 39 39 + Ok(()) 40 40 + }

+41 -1

crates/server/src/handlers/system.rs

··· 2 2 3 3 use crate::http::{Context, Request, Response}; 4 4 use anyhow::Error; 5 5 - use rockbox_library::audio_scan::scan_audio_files; 5 5 + use rockbox_library::{audio_scan::scan_audio_files, repo}; 6 6 + use rockbox_search::{ 7 7 + index_albums, index_artists, index_liked_albums, index_liked_tracks, index_track, index_tracks, 8 8 + rockbox::search::v1alpha1::{AlbumList, ArtistList, LikedAlbumList, LikedTrackList, TrackList}, 9 9 + }; 6 10 use rockbox_sys as rb; 7 11 8 12 pub async fn get_status(_ctx: &Context, _req: &Request, res: &mut Response) -> Result<(), Error> { ··· 25 29 let home = env::var("HOME")?; 26 30 let path = env::var("ROCKBOX_LIBRARY").unwrap_or(format!("{}/Music", home)); 27 31 scan_audio_files(ctx.pool.clone(), path.into()).await?; 32 32 + let tracks = repo::track::all(ctx.pool.clone()).await?; 33 33 + let albums = repo::album::all(ctx.pool.clone()).await?; 34 34 + let artists = repo::artist::all(ctx.pool.clone()).await?; 35 35 + let liked_albums = repo::favourites::all_albums(ctx.pool.clone()).await?; 36 36 + let liked_tracks = repo::favourites::all_tracks(ctx.pool.clone()).await?; 37 37 + 38 38 + index_tracks(TrackList { 39 39 + tracks: tracks.clone().into_iter().map(Into::into).collect(), 40 40 + })?; 41 41 + 42 42 + println!("Successfully indexed {} tracks", tracks.len()); 43 43 + 44 44 + index_liked_albums(LikedAlbumList { 45 45 + albums: liked_albums.clone().into_iter().map(Into::into).collect(), 46 46 + })?; 47 47 + 48 48 + println!("Successfully indexed {} liked albums", liked_albums.len()); 49 49 + 50 50 + index_liked_tracks(LikedTrackList { 51 51 + tracks: liked_tracks.clone().into_iter().map(Into::into).collect(), 52 52 + })?; 53 53 + 54 54 + println!("Successfully indexed {} liked tracks", liked_tracks.len()); 55 55 + 56 56 + index_albums(AlbumList { 57 57 + albums: albums.clone().into_iter().map(Into::into).collect(), 58 58 + })?; 59 59 + 60 60 + println!("Successfully indexed {} albums", albums.len()); 61 61 + 62 62 + index_artists(ArtistList { 63 63 + artists: artists.clone().into_iter().map(Into::into).collect(), 64 64 + })?; 65 65 + 66 66 + println!("Successfully indexed {} artists", artists.len()); 67 67 + 28 68 res.text("0"); 29 69 Ok(()) 30 70 }

+1 -1

crates/server/src/lib.rs

··· 18 18 pub mod cache; 19 19 pub mod handlers; 20 20 pub mod http; 21 21 - pub mod types; 22 21 23 22 pub const AUDIO_EXTENSIONS: [&str; 17] = [ 24 23 "mp3", "ogg", "flac", "m4a", "aac", "mp4", "alac", "wav", "wv", "mpc", "aiff", "ac3", "opus", ··· 79 78 app.get("/status", get_status); 80 79 app.get("/settings", get_global_settings); 81 80 app.put("/scan-library", scan_library); 81 81 + app.get("/search", search); 82 82 83 83 app.get("/", index); 84 84 app.get("/operations/:id", index);

+11

crates/server/src/types.rs crates/types/src/lib.rs

··· 1 1 + use rockbox_search::rockbox::search::v1alpha1::*; 1 2 use serde::{Deserialize, Serialize}; 2 3 3 4 #[derive(Debug, Serialize, Deserialize)] ··· 28 29 pub struct StatusCode { 29 30 pub code: i32, 30 31 } 32 32 + 33 33 + #[derive(Default, Serialize, Deserialize)] 34 34 + pub struct SearchResults { 35 35 + pub artists: Vec<Artist>, 36 36 + pub albums: Vec<Album>, 37 37 + pub tracks: Vec<Track>, 38 38 + pub liked_tracks: Vec<LikedTrack>, 39 39 + pub liked_albums: Vec<LikedAlbum>, 40 40 + pub files: Vec<File>, 41 41 + }

+8

crates/types/Cargo.toml

··· 1 1 + [package] 2 2 + edition = "2021" 3 3 + name = "rockbox-types" 4 4 + version = "0.1.0" 5 5 + 6 6 + [dependencies] 7 7 + rockbox-search = {path = "../search"} 8 8 + serde = {version = "1.0.213", features = ["derive"]}

+2

search/.gitignore

··· 1 1 + *.bleve 2 2 + *.a

+281

search/gen/rockbox/search/v1alpha1/album.pb.go

··· 1 1 + // Code generated by protoc-gen-go. DO NOT EDIT. 2 2 + // versions: 3 3 + // protoc-gen-go v1.31.0 4 4 + // protoc (unknown) 5 5 + // source: rockbox/search/v1alpha1/album.proto 6 6 + 7 7 + package v1alpha1 8 8 + 9 9 + import ( 10 10 + protoreflect "google.golang.org/protobuf/reflect/protoreflect" 11 11 + protoimpl "google.golang.org/protobuf/runtime/protoimpl" 12 12 + reflect "reflect" 13 13 + sync "sync" 14 14 + ) 15 15 + 16 16 + const ( 17 17 + // Verify that this generated code is sufficiently up-to-date. 18 18 + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) 19 19 + // Verify that runtime/protoimpl is sufficiently up-to-date. 20 20 + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) 21 21 + ) 22 22 + 23 23 + type Album struct { 24 24 + state protoimpl.MessageState 25 25 + sizeCache protoimpl.SizeCache 26 26 + unknownFields protoimpl.UnknownFields 27 27 + 28 28 + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 29 29 + Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"` 30 30 + Artist string `protobuf:"bytes,3,opt,name=artist,proto3" json:"artist,omitempty"` 31 31 + Year uint32 `protobuf:"varint,4,opt,name=year,proto3" json:"year,omitempty"` 32 32 + YearString string `protobuf:"bytes,5,opt,name=year_string,json=yearString,proto3" json:"year_string,omitempty"` 33 33 + AlbumArt *string `protobuf:"bytes,6,opt,name=album_art,json=albumArt,proto3,oneof" json:"album_art,omitempty"` 34 34 + Md5 string `protobuf:"bytes,7,opt,name=md5,proto3" json:"md5,omitempty"` 35 35 + ArtistId string `protobuf:"bytes,8,opt,name=artist_id,json=artistId,proto3" json:"artist_id,omitempty"` 36 36 + } 37 37 + 38 38 + func (x *Album) Reset() { 39 39 + *x = Album{} 40 40 + if protoimpl.UnsafeEnabled { 41 41 + mi := &file_rockbox_search_v1alpha1_album_proto_msgTypes[0] 42 42 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 43 43 + ms.StoreMessageInfo(mi) 44 44 + } 45 45 + } 46 46 + 47 47 + func (x *Album) String() string { 48 48 + return protoimpl.X.MessageStringOf(x) 49 49 + } 50 50 + 51 51 + func (*Album) ProtoMessage() {} 52 52 + 53 53 + func (x *Album) ProtoReflect() protoreflect.Message { 54 54 + mi := &file_rockbox_search_v1alpha1_album_proto_msgTypes[0] 55 55 + if protoimpl.UnsafeEnabled && x != nil { 56 56 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 57 57 + if ms.LoadMessageInfo() == nil { 58 58 + ms.StoreMessageInfo(mi) 59 59 + } 60 60 + return ms 61 61 + } 62 62 + return mi.MessageOf(x) 63 63 + } 64 64 + 65 65 + // Deprecated: Use Album.ProtoReflect.Descriptor instead. 66 66 + func (*Album) Descriptor() ([]byte, []int) { 67 67 + return file_rockbox_search_v1alpha1_album_proto_rawDescGZIP(), []int{0} 68 68 + } 69 69 + 70 70 + func (x *Album) GetId() string { 71 71 + if x != nil { 72 72 + return x.Id 73 73 + } 74 74 + return "" 75 75 + } 76 76 + 77 77 + func (x *Album) GetTitle() string { 78 78 + if x != nil { 79 79 + return x.Title 80 80 + } 81 81 + return "" 82 82 + } 83 83 + 84 84 + func (x *Album) GetArtist() string { 85 85 + if x != nil { 86 86 + return x.Artist 87 87 + } 88 88 + return "" 89 89 + } 90 90 + 91 91 + func (x *Album) GetYear() uint32 { 92 92 + if x != nil { 93 93 + return x.Year 94 94 + } 95 95 + return 0 96 96 + } 97 97 + 98 98 + func (x *Album) GetYearString() string { 99 99 + if x != nil { 100 100 + return x.YearString 101 101 + } 102 102 + return "" 103 103 + } 104 104 + 105 105 + func (x *Album) GetAlbumArt() string { 106 106 + if x != nil && x.AlbumArt != nil { 107 107 + return *x.AlbumArt 108 108 + } 109 109 + return "" 110 110 + } 111 111 + 112 112 + func (x *Album) GetMd5() string { 113 113 + if x != nil { 114 114 + return x.Md5 115 115 + } 116 116 + return "" 117 117 + } 118 118 + 119 119 + func (x *Album) GetArtistId() string { 120 120 + if x != nil { 121 121 + return x.ArtistId 122 122 + } 123 123 + return "" 124 124 + } 125 125 + 126 126 + type AlbumList struct { 127 127 + state protoimpl.MessageState 128 128 + sizeCache protoimpl.SizeCache 129 129 + unknownFields protoimpl.UnknownFields 130 130 + 131 131 + Albums []*Album `protobuf:"bytes,1,rep,name=albums,proto3" json:"albums,omitempty"` 132 132 + } 133 133 + 134 134 + func (x *AlbumList) Reset() { 135 135 + *x = AlbumList{} 136 136 + if protoimpl.UnsafeEnabled { 137 137 + mi := &file_rockbox_search_v1alpha1_album_proto_msgTypes[1] 138 138 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 139 139 + ms.StoreMessageInfo(mi) 140 140 + } 141 141 + } 142 142 + 143 143 + func (x *AlbumList) String() string { 144 144 + return protoimpl.X.MessageStringOf(x) 145 145 + } 146 146 + 147 147 + func (*AlbumList) ProtoMessage() {} 148 148 + 149 149 + func (x *AlbumList) ProtoReflect() protoreflect.Message { 150 150 + mi := &file_rockbox_search_v1alpha1_album_proto_msgTypes[1] 151 151 + if protoimpl.UnsafeEnabled && x != nil { 152 152 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 153 153 + if ms.LoadMessageInfo() == nil { 154 154 + ms.StoreMessageInfo(mi) 155 155 + } 156 156 + return ms 157 157 + } 158 158 + return mi.MessageOf(x) 159 159 + } 160 160 + 161 161 + // Deprecated: Use AlbumList.ProtoReflect.Descriptor instead. 162 162 + func (*AlbumList) Descriptor() ([]byte, []int) { 163 163 + return file_rockbox_search_v1alpha1_album_proto_rawDescGZIP(), []int{1} 164 164 + } 165 165 + 166 166 + func (x *AlbumList) GetAlbums() []*Album { 167 167 + if x != nil { 168 168 + return x.Albums 169 169 + } 170 170 + return nil 171 171 + } 172 172 + 173 173 + var File_rockbox_search_v1alpha1_album_proto protoreflect.FileDescriptor 174 174 + 175 175 + var file_rockbox_search_v1alpha1_album_proto_rawDesc = []byte{ 176 176 + 0x0a, 0x23, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2f, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 177 177 + 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x2e, 178 178 + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x17, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2e, 0x73, 179 179 + 0x65, 0x61, 0x72, 0x63, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x22, 0xd9, 180 180 + 0x01, 0x0a, 0x05, 0x41, 0x6c, 0x62, 0x75, 0x6d, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 181 181 + 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x69, 0x74, 0x6c, 182 182 + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x12, 0x16, 183 183 + 0x0a, 0x06, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 184 184 + 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x79, 0x65, 0x61, 0x72, 0x18, 0x04, 185 185 + 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x79, 0x65, 0x61, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x79, 0x65, 186 186 + 0x61, 0x72, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 187 187 + 0x0a, 0x79, 0x65, 0x61, 0x72, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x20, 0x0a, 0x09, 0x61, 188 188 + 0x6c, 0x62, 0x75, 0x6d, 0x5f, 0x61, 0x72, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 189 189 + 0x52, 0x08, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x41, 0x72, 0x74, 0x88, 0x01, 0x01, 0x12, 0x10, 0x0a, 190 190 + 0x03, 0x6d, 0x64, 0x35, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6d, 0x64, 0x35, 0x12, 191 191 + 0x1b, 0x0a, 0x09, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x08, 0x20, 0x01, 192 192 + 0x28, 0x09, 0x52, 0x08, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x49, 0x64, 0x42, 0x0c, 0x0a, 0x0a, 193 193 + 0x5f, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x5f, 0x61, 0x72, 0x74, 0x22, 0x43, 0x0a, 0x09, 0x41, 0x6c, 194 194 + 0x62, 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x36, 0x0a, 0x06, 0x61, 0x6c, 0x62, 0x75, 0x6d, 195 195 + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 196 196 + 0x78, 0x2e, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 197 197 + 0x31, 0x2e, 0x41, 0x6c, 0x62, 0x75, 0x6d, 0x52, 0x06, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x73, 0x42, 198 198 + 0x3e, 0x5a, 0x3c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x74, 0x73, 199 199 + 0x69, 0x72, 0x79, 0x73, 0x6e, 0x64, 0x72, 0x2f, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2d, 200 200 + 0x7a, 0x69, 0x67, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2f, 201 201 + 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62, 202 202 + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 203 203 + } 204 204 + 205 205 + var ( 206 206 + file_rockbox_search_v1alpha1_album_proto_rawDescOnce sync.Once 207 207 + file_rockbox_search_v1alpha1_album_proto_rawDescData = file_rockbox_search_v1alpha1_album_proto_rawDesc 208 208 + ) 209 209 + 210 210 + func file_rockbox_search_v1alpha1_album_proto_rawDescGZIP() []byte { 211 211 + file_rockbox_search_v1alpha1_album_proto_rawDescOnce.Do(func() { 212 212 + file_rockbox_search_v1alpha1_album_proto_rawDescData = protoimpl.X.CompressGZIP(file_rockbox_search_v1alpha1_album_proto_rawDescData) 213 213 + }) 214 214 + return file_rockbox_search_v1alpha1_album_proto_rawDescData 215 215 + } 216 216 + 217 217 + var file_rockbox_search_v1alpha1_album_proto_msgTypes = make([]protoimpl.MessageInfo, 2) 218 218 + var file_rockbox_search_v1alpha1_album_proto_goTypes = []interface{}{ 219 219 + (*Album)(nil), // 0: rockbox.search.v1alpha1.Album 220 220 + (*AlbumList)(nil), // 1: rockbox.search.v1alpha1.AlbumList 221 221 + } 222 222 + var file_rockbox_search_v1alpha1_album_proto_depIdxs = []int32{ 223 223 + 0, // 0: rockbox.search.v1alpha1.AlbumList.albums:type_name -> rockbox.search.v1alpha1.Album 224 224 + 1, // [1:1] is the sub-list for method output_type 225 225 + 1, // [1:1] is the sub-list for method input_type 226 226 + 1, // [1:1] is the sub-list for extension type_name 227 227 + 1, // [1:1] is the sub-list for extension extendee 228 228 + 0, // [0:1] is the sub-list for field type_name 229 229 + } 230 230 + 231 231 + func init() { file_rockbox_search_v1alpha1_album_proto_init() } 232 232 + func file_rockbox_search_v1alpha1_album_proto_init() { 233 233 + if File_rockbox_search_v1alpha1_album_proto != nil { 234 234 + return 235 235 + } 236 236 + if !protoimpl.UnsafeEnabled { 237 237 + file_rockbox_search_v1alpha1_album_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { 238 238 + switch v := v.(*Album); i { 239 239 + case 0: 240 240 + return &v.state 241 241 + case 1: 242 242 + return &v.sizeCache 243 243 + case 2: 244 244 + return &v.unknownFields 245 245 + default: 246 246 + return nil 247 247 + } 248 248 + } 249 249 + file_rockbox_search_v1alpha1_album_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { 250 250 + switch v := v.(*AlbumList); i { 251 251 + case 0: 252 252 + return &v.state 253 253 + case 1: 254 254 + return &v.sizeCache 255 255 + case 2: 256 256 + return &v.unknownFields 257 257 + default: 258 258 + return nil 259 259 + } 260 260 + } 261 261 + } 262 262 + file_rockbox_search_v1alpha1_album_proto_msgTypes[0].OneofWrappers = []interface{}{} 263 263 + type x struct{} 264 264 + out := protoimpl.TypeBuilder{ 265 265 + File: protoimpl.DescBuilder{ 266 266 + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), 267 267 + RawDescriptor: file_rockbox_search_v1alpha1_album_proto_rawDesc, 268 268 + NumEnums: 0, 269 269 + NumMessages: 2, 270 270 + NumExtensions: 0, 271 271 + NumServices: 0, 272 272 + }, 273 273 + GoTypes: file_rockbox_search_v1alpha1_album_proto_goTypes, 274 274 + DependencyIndexes: file_rockbox_search_v1alpha1_album_proto_depIdxs, 275 275 + MessageInfos: file_rockbox_search_v1alpha1_album_proto_msgTypes, 276 276 + }.Build() 277 277 + File_rockbox_search_v1alpha1_album_proto = out.File 278 278 + file_rockbox_search_v1alpha1_album_proto_rawDesc = nil 279 279 + file_rockbox_search_v1alpha1_album_proto_goTypes = nil 280 280 + file_rockbox_search_v1alpha1_album_proto_depIdxs = nil 281 281 + }

+237

search/gen/rockbox/search/v1alpha1/all.pb.go

··· 1 1 + // Code generated by protoc-gen-go. DO NOT EDIT. 2 2 + // versions: 3 3 + // protoc-gen-go v1.31.0 4 4 + // protoc (unknown) 5 5 + // source: rockbox/search/v1alpha1/all.proto 6 6 + 7 7 + package v1alpha1 8 8 + 9 9 + import ( 10 10 + protoreflect "google.golang.org/protobuf/reflect/protoreflect" 11 11 + protoimpl "google.golang.org/protobuf/runtime/protoimpl" 12 12 + reflect "reflect" 13 13 + sync "sync" 14 14 + ) 15 15 + 16 16 + const ( 17 17 + // Verify that this generated code is sufficiently up-to-date. 18 18 + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) 19 19 + // Verify that runtime/protoimpl is sufficiently up-to-date. 20 20 + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) 21 21 + ) 22 22 + 23 23 + type All struct { 24 24 + state protoimpl.MessageState 25 25 + sizeCache protoimpl.SizeCache 26 26 + unknownFields protoimpl.UnknownFields 27 27 + 28 28 + Albums []*Album `protobuf:"bytes,1,rep,name=albums,proto3" json:"albums,omitempty"` 29 29 + Artists []*Artist `protobuf:"bytes,2,rep,name=artists,proto3" json:"artists,omitempty"` 30 30 + Files []*File `protobuf:"bytes,3,rep,name=files,proto3" json:"files,omitempty"` 31 31 + LikedAlbums []*LikedAlbum `protobuf:"bytes,4,rep,name=liked_albums,json=likedAlbums,proto3" json:"liked_albums,omitempty"` 32 32 + LikedTrack []*LikedTrack `protobuf:"bytes,5,rep,name=liked_track,json=likedTrack,proto3" json:"liked_track,omitempty"` 33 33 + Tracks []*Track `protobuf:"bytes,6,rep,name=tracks,proto3" json:"tracks,omitempty"` 34 34 + } 35 35 + 36 36 + func (x *All) Reset() { 37 37 + *x = All{} 38 38 + if protoimpl.UnsafeEnabled { 39 39 + mi := &file_rockbox_search_v1alpha1_all_proto_msgTypes[0] 40 40 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 41 41 + ms.StoreMessageInfo(mi) 42 42 + } 43 43 + } 44 44 + 45 45 + func (x *All) String() string { 46 46 + return protoimpl.X.MessageStringOf(x) 47 47 + } 48 48 + 49 49 + func (*All) ProtoMessage() {} 50 50 + 51 51 + func (x *All) ProtoReflect() protoreflect.Message { 52 52 + mi := &file_rockbox_search_v1alpha1_all_proto_msgTypes[0] 53 53 + if protoimpl.UnsafeEnabled && x != nil { 54 54 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 55 55 + if ms.LoadMessageInfo() == nil { 56 56 + ms.StoreMessageInfo(mi) 57 57 + } 58 58 + return ms 59 59 + } 60 60 + return mi.MessageOf(x) 61 61 + } 62 62 + 63 63 + // Deprecated: Use All.ProtoReflect.Descriptor instead. 64 64 + func (*All) Descriptor() ([]byte, []int) { 65 65 + return file_rockbox_search_v1alpha1_all_proto_rawDescGZIP(), []int{0} 66 66 + } 67 67 + 68 68 + func (x *All) GetAlbums() []*Album { 69 69 + if x != nil { 70 70 + return x.Albums 71 71 + } 72 72 + return nil 73 73 + } 74 74 + 75 75 + func (x *All) GetArtists() []*Artist { 76 76 + if x != nil { 77 77 + return x.Artists 78 78 + } 79 79 + return nil 80 80 + } 81 81 + 82 82 + func (x *All) GetFiles() []*File { 83 83 + if x != nil { 84 84 + return x.Files 85 85 + } 86 86 + return nil 87 87 + } 88 88 + 89 89 + func (x *All) GetLikedAlbums() []*LikedAlbum { 90 90 + if x != nil { 91 91 + return x.LikedAlbums 92 92 + } 93 93 + return nil 94 94 + } 95 95 + 96 96 + func (x *All) GetLikedTrack() []*LikedTrack { 97 97 + if x != nil { 98 98 + return x.LikedTrack 99 99 + } 100 100 + return nil 101 101 + } 102 102 + 103 103 + func (x *All) GetTracks() []*Track { 104 104 + if x != nil { 105 105 + return x.Tracks 106 106 + } 107 107 + return nil 108 108 + } 109 109 + 110 110 + var File_rockbox_search_v1alpha1_all_proto protoreflect.FileDescriptor 111 111 + 112 112 + var file_rockbox_search_v1alpha1_all_proto_rawDesc = []byte{ 113 113 + 0x0a, 0x21, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2f, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 114 114 + 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x61, 0x6c, 0x6c, 0x2e, 0x70, 0x72, 115 115 + 0x6f, 0x74, 0x6f, 0x12, 0x17, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2e, 0x73, 0x65, 0x61, 116 116 + 0x72, 0x63, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x1a, 0x23, 0x72, 0x6f, 117 117 + 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2f, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2f, 0x76, 0x31, 0x61, 118 118 + 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x2e, 0x70, 0x72, 0x6f, 0x74, 119 119 + 0x6f, 0x1a, 0x24, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2f, 0x73, 0x65, 0x61, 0x72, 0x63, 120 120 + 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x73, 121 121 + 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x22, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 122 122 + 0x2f, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 123 123 + 0x2f, 0x66, 0x69, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x22, 0x72, 0x6f, 0x63, 124 124 + 0x6b, 0x62, 0x6f, 0x78, 0x2f, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 125 125 + 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6c, 0x69, 0x6b, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 126 126 + 0x23, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2f, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2f, 127 127 + 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x2e, 0x70, 128 128 + 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xf3, 0x02, 0x0a, 0x03, 0x41, 0x6c, 0x6c, 0x12, 0x36, 0x0a, 0x06, 129 129 + 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 130 130 + 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2e, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2e, 0x76, 0x31, 131 131 + 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x41, 0x6c, 0x62, 0x75, 0x6d, 0x52, 0x06, 0x61, 0x6c, 132 132 + 0x62, 0x75, 0x6d, 0x73, 0x12, 0x39, 0x0a, 0x07, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x73, 0x18, 133 133 + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2e, 134 134 + 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 135 135 + 0x41, 0x72, 0x74, 0x69, 0x73, 0x74, 0x52, 0x07, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x73, 0x12, 136 136 + 0x33, 0x0a, 0x05, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 137 137 + 0x2e, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2e, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2e, 138 138 + 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x52, 0x05, 0x66, 139 139 + 0x69, 0x6c, 0x65, 0x73, 0x12, 0x46, 0x0a, 0x0c, 0x6c, 0x69, 0x6b, 0x65, 0x64, 0x5f, 0x61, 0x6c, 140 140 + 0x62, 0x75, 0x6d, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x72, 0x6f, 0x63, 141 141 + 0x6b, 0x62, 0x6f, 0x78, 0x2e, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 142 142 + 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x6b, 0x65, 0x64, 0x41, 0x6c, 0x62, 0x75, 0x6d, 0x52, 143 143 + 0x0b, 0x6c, 0x69, 0x6b, 0x65, 0x64, 0x41, 0x6c, 0x62, 0x75, 0x6d, 0x73, 0x12, 0x44, 0x0a, 0x0b, 144 144 + 0x6c, 0x69, 0x6b, 0x65, 0x64, 0x5f, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x18, 0x05, 0x20, 0x03, 0x28, 145 145 + 0x0b, 0x32, 0x23, 0x2e, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2e, 0x73, 0x65, 0x61, 0x72, 146 146 + 0x63, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x6b, 0x65, 147 147 + 0x64, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x52, 0x0a, 0x6c, 0x69, 0x6b, 0x65, 0x64, 0x54, 0x72, 0x61, 148 148 + 0x63, 0x6b, 0x12, 0x36, 0x0a, 0x06, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x73, 0x18, 0x06, 0x20, 0x03, 149 149 + 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2e, 0x73, 0x65, 0x61, 150 150 + 0x72, 0x63, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x54, 0x72, 0x61, 151 151 + 0x63, 0x6b, 0x52, 0x06, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x73, 0x42, 0x3e, 0x5a, 0x3c, 0x67, 0x69, 152 152 + 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x74, 0x73, 0x69, 0x72, 0x79, 0x73, 0x6e, 153 153 + 0x64, 0x72, 0x2f, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2d, 0x7a, 0x69, 0x67, 0x2f, 0x67, 154 154 + 0x65, 0x6e, 0x2f, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2f, 0x73, 0x65, 0x61, 0x72, 0x63, 155 155 + 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 156 156 + 0x6f, 0x33, 157 157 + } 158 158 + 159 159 + var ( 160 160 + file_rockbox_search_v1alpha1_all_proto_rawDescOnce sync.Once 161 161 + file_rockbox_search_v1alpha1_all_proto_rawDescData = file_rockbox_search_v1alpha1_all_proto_rawDesc 162 162 + ) 163 163 + 164 164 + func file_rockbox_search_v1alpha1_all_proto_rawDescGZIP() []byte { 165 165 + file_rockbox_search_v1alpha1_all_proto_rawDescOnce.Do(func() { 166 166 + file_rockbox_search_v1alpha1_all_proto_rawDescData = protoimpl.X.CompressGZIP(file_rockbox_search_v1alpha1_all_proto_rawDescData) 167 167 + }) 168 168 + return file_rockbox_search_v1alpha1_all_proto_rawDescData 169 169 + } 170 170 + 171 171 + var file_rockbox_search_v1alpha1_all_proto_msgTypes = make([]protoimpl.MessageInfo, 1) 172 172 + var file_rockbox_search_v1alpha1_all_proto_goTypes = []interface{}{ 173 173 + (*All)(nil), // 0: rockbox.search.v1alpha1.All 174 174 + (*Album)(nil), // 1: rockbox.search.v1alpha1.Album 175 175 + (*Artist)(nil), // 2: rockbox.search.v1alpha1.Artist 176 176 + (*File)(nil), // 3: rockbox.search.v1alpha1.File 177 177 + (*LikedAlbum)(nil), // 4: rockbox.search.v1alpha1.LikedAlbum 178 178 + (*LikedTrack)(nil), // 5: rockbox.search.v1alpha1.LikedTrack 179 179 + (*Track)(nil), // 6: rockbox.search.v1alpha1.Track 180 180 + } 181 181 + var file_rockbox_search_v1alpha1_all_proto_depIdxs = []int32{ 182 182 + 1, // 0: rockbox.search.v1alpha1.All.albums:type_name -> rockbox.search.v1alpha1.Album 183 183 + 2, // 1: rockbox.search.v1alpha1.All.artists:type_name -> rockbox.search.v1alpha1.Artist 184 184 + 3, // 2: rockbox.search.v1alpha1.All.files:type_name -> rockbox.search.v1alpha1.File 185 185 + 4, // 3: rockbox.search.v1alpha1.All.liked_albums:type_name -> rockbox.search.v1alpha1.LikedAlbum 186 186 + 5, // 4: rockbox.search.v1alpha1.All.liked_track:type_name -> rockbox.search.v1alpha1.LikedTrack 187 187 + 6, // 5: rockbox.search.v1alpha1.All.tracks:type_name -> rockbox.search.v1alpha1.Track 188 188 + 6, // [6:6] is the sub-list for method output_type 189 189 + 6, // [6:6] is the sub-list for method input_type 190 190 + 6, // [6:6] is the sub-list for extension type_name 191 191 + 6, // [6:6] is the sub-list for extension extendee 192 192 + 0, // [0:6] is the sub-list for field type_name 193 193 + } 194 194 + 195 195 + func init() { file_rockbox_search_v1alpha1_all_proto_init() } 196 196 + func file_rockbox_search_v1alpha1_all_proto_init() { 197 197 + if File_rockbox_search_v1alpha1_all_proto != nil { 198 198 + return 199 199 + } 200 200 + file_rockbox_search_v1alpha1_album_proto_init() 201 201 + file_rockbox_search_v1alpha1_artist_proto_init() 202 202 + file_rockbox_search_v1alpha1_file_proto_init() 203 203 + file_rockbox_search_v1alpha1_like_proto_init() 204 204 + file_rockbox_search_v1alpha1_track_proto_init() 205 205 + if !protoimpl.UnsafeEnabled { 206 206 + file_rockbox_search_v1alpha1_all_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { 207 207 + switch v := v.(*All); i { 208 208 + case 0: 209 209 + return &v.state 210 210 + case 1: 211 211 + return &v.sizeCache 212 212 + case 2: 213 213 + return &v.unknownFields 214 214 + default: 215 215 + return nil 216 216 + } 217 217 + } 218 218 + } 219 219 + type x struct{} 220 220 + out := protoimpl.TypeBuilder{ 221 221 + File: protoimpl.DescBuilder{ 222 222 + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), 223 223 + RawDescriptor: file_rockbox_search_v1alpha1_all_proto_rawDesc, 224 224 + NumEnums: 0, 225 225 + NumMessages: 1, 226 226 + NumExtensions: 0, 227 227 + NumServices: 0, 228 228 + }, 229 229 + GoTypes: file_rockbox_search_v1alpha1_all_proto_goTypes, 230 230 + DependencyIndexes: file_rockbox_search_v1alpha1_all_proto_depIdxs, 231 231 + MessageInfos: file_rockbox_search_v1alpha1_all_proto_msgTypes, 232 232 + }.Build() 233 233 + File_rockbox_search_v1alpha1_all_proto = out.File 234 234 + file_rockbox_search_v1alpha1_all_proto_rawDesc = nil 235 235 + file_rockbox_search_v1alpha1_all_proto_goTypes = nil 236 236 + file_rockbox_search_v1alpha1_all_proto_depIdxs = nil 237 237 + }

+243

search/gen/rockbox/search/v1alpha1/artist.pb.go

··· 1 1 + // Code generated by protoc-gen-go. DO NOT EDIT. 2 2 + // versions: 3 3 + // protoc-gen-go v1.31.0 4 4 + // protoc (unknown) 5 5 + // source: rockbox/search/v1alpha1/artist.proto 6 6 + 7 7 + package v1alpha1 8 8 + 9 9 + import ( 10 10 + protoreflect "google.golang.org/protobuf/reflect/protoreflect" 11 11 + protoimpl "google.golang.org/protobuf/runtime/protoimpl" 12 12 + reflect "reflect" 13 13 + sync "sync" 14 14 + ) 15 15 + 16 16 + const ( 17 17 + // Verify that this generated code is sufficiently up-to-date. 18 18 + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) 19 19 + // Verify that runtime/protoimpl is sufficiently up-to-date. 20 20 + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) 21 21 + ) 22 22 + 23 23 + type Artist struct { 24 24 + state protoimpl.MessageState 25 25 + sizeCache protoimpl.SizeCache 26 26 + unknownFields protoimpl.UnknownFields 27 27 + 28 28 + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 29 29 + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` 30 30 + Bio *string `protobuf:"bytes,3,opt,name=bio,proto3,oneof" json:"bio,omitempty"` 31 31 + Image *string `protobuf:"bytes,4,opt,name=image,proto3,oneof" json:"image,omitempty"` 32 32 + } 33 33 + 34 34 + func (x *Artist) Reset() { 35 35 + *x = Artist{} 36 36 + if protoimpl.UnsafeEnabled { 37 37 + mi := &file_rockbox_search_v1alpha1_artist_proto_msgTypes[0] 38 38 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 39 39 + ms.StoreMessageInfo(mi) 40 40 + } 41 41 + } 42 42 + 43 43 + func (x *Artist) String() string { 44 44 + return protoimpl.X.MessageStringOf(x) 45 45 + } 46 46 + 47 47 + func (*Artist) ProtoMessage() {} 48 48 + 49 49 + func (x *Artist) ProtoReflect() protoreflect.Message { 50 50 + mi := &file_rockbox_search_v1alpha1_artist_proto_msgTypes[0] 51 51 + if protoimpl.UnsafeEnabled && x != nil { 52 52 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 53 53 + if ms.LoadMessageInfo() == nil { 54 54 + ms.StoreMessageInfo(mi) 55 55 + } 56 56 + return ms 57 57 + } 58 58 + return mi.MessageOf(x) 59 59 + } 60 60 + 61 61 + // Deprecated: Use Artist.ProtoReflect.Descriptor instead. 62 62 + func (*Artist) Descriptor() ([]byte, []int) { 63 63 + return file_rockbox_search_v1alpha1_artist_proto_rawDescGZIP(), []int{0} 64 64 + } 65 65 + 66 66 + func (x *Artist) GetId() string { 67 67 + if x != nil { 68 68 + return x.Id 69 69 + } 70 70 + return "" 71 71 + } 72 72 + 73 73 + func (x *Artist) GetName() string { 74 74 + if x != nil { 75 75 + return x.Name 76 76 + } 77 77 + return "" 78 78 + } 79 79 + 80 80 + func (x *Artist) GetBio() string { 81 81 + if x != nil && x.Bio != nil { 82 82 + return *x.Bio 83 83 + } 84 84 + return "" 85 85 + } 86 86 + 87 87 + func (x *Artist) GetImage() string { 88 88 + if x != nil && x.Image != nil { 89 89 + return *x.Image 90 90 + } 91 91 + return "" 92 92 + } 93 93 + 94 94 + type ArtistList struct { 95 95 + state protoimpl.MessageState 96 96 + sizeCache protoimpl.SizeCache 97 97 + unknownFields protoimpl.UnknownFields 98 98 + 99 99 + Artists []*Artist `protobuf:"bytes,1,rep,name=artists,proto3" json:"artists,omitempty"` 100 100 + } 101 101 + 102 102 + func (x *ArtistList) Reset() { 103 103 + *x = ArtistList{} 104 104 + if protoimpl.UnsafeEnabled { 105 105 + mi := &file_rockbox_search_v1alpha1_artist_proto_msgTypes[1] 106 106 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 107 107 + ms.StoreMessageInfo(mi) 108 108 + } 109 109 + } 110 110 + 111 111 + func (x *ArtistList) String() string { 112 112 + return protoimpl.X.MessageStringOf(x) 113 113 + } 114 114 + 115 115 + func (*ArtistList) ProtoMessage() {} 116 116 + 117 117 + func (x *ArtistList) ProtoReflect() protoreflect.Message { 118 118 + mi := &file_rockbox_search_v1alpha1_artist_proto_msgTypes[1] 119 119 + if protoimpl.UnsafeEnabled && x != nil { 120 120 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 121 121 + if ms.LoadMessageInfo() == nil { 122 122 + ms.StoreMessageInfo(mi) 123 123 + } 124 124 + return ms 125 125 + } 126 126 + return mi.MessageOf(x) 127 127 + } 128 128 + 129 129 + // Deprecated: Use ArtistList.ProtoReflect.Descriptor instead. 130 130 + func (*ArtistList) Descriptor() ([]byte, []int) { 131 131 + return file_rockbox_search_v1alpha1_artist_proto_rawDescGZIP(), []int{1} 132 132 + } 133 133 + 134 134 + func (x *ArtistList) GetArtists() []*Artist { 135 135 + if x != nil { 136 136 + return x.Artists 137 137 + } 138 138 + return nil 139 139 + } 140 140 + 141 141 + var File_rockbox_search_v1alpha1_artist_proto protoreflect.FileDescriptor 142 142 + 143 143 + var file_rockbox_search_v1alpha1_artist_proto_rawDesc = []byte{ 144 144 + 0x0a, 0x24, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2f, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 145 145 + 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 146 146 + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x17, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2e, 147 147 + 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x22, 148 148 + 0x70, 0x0a, 0x06, 0x41, 0x72, 0x74, 0x69, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 149 149 + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 150 150 + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x15, 0x0a, 151 151 + 0x03, 0x62, 0x69, 0x6f, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x03, 0x62, 0x69, 152 152 + 0x6f, 0x88, 0x01, 0x01, 0x12, 0x19, 0x0a, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 153 153 + 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x88, 0x01, 0x01, 0x42, 154 154 + 0x06, 0x0a, 0x04, 0x5f, 0x62, 0x69, 0x6f, 0x42, 0x08, 0x0a, 0x06, 0x5f, 0x69, 0x6d, 0x61, 0x67, 155 155 + 0x65, 0x22, 0x47, 0x0a, 0x0a, 0x41, 0x72, 0x74, 0x69, 0x73, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x12, 156 156 + 0x39, 0x0a, 0x07, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 157 157 + 0x32, 0x1f, 0x2e, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2e, 0x73, 0x65, 0x61, 0x72, 0x63, 158 158 + 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x73, 159 159 + 0x74, 0x52, 0x07, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x73, 0x42, 0x3e, 0x5a, 0x3c, 0x67, 0x69, 160 160 + 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x74, 0x73, 0x69, 0x72, 0x79, 0x73, 0x6e, 161 161 + 0x64, 0x72, 0x2f, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2d, 0x7a, 0x69, 0x67, 0x2f, 0x67, 162 162 + 0x65, 0x6e, 0x2f, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2f, 0x73, 0x65, 0x61, 0x72, 0x63, 163 163 + 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 164 164 + 0x6f, 0x33, 165 165 + } 166 166 + 167 167 + var ( 168 168 + file_rockbox_search_v1alpha1_artist_proto_rawDescOnce sync.Once 169 169 + file_rockbox_search_v1alpha1_artist_proto_rawDescData = file_rockbox_search_v1alpha1_artist_proto_rawDesc 170 170 + ) 171 171 + 172 172 + func file_rockbox_search_v1alpha1_artist_proto_rawDescGZIP() []byte { 173 173 + file_rockbox_search_v1alpha1_artist_proto_rawDescOnce.Do(func() { 174 174 + file_rockbox_search_v1alpha1_artist_proto_rawDescData = protoimpl.X.CompressGZIP(file_rockbox_search_v1alpha1_artist_proto_rawDescData) 175 175 + }) 176 176 + return file_rockbox_search_v1alpha1_artist_proto_rawDescData 177 177 + } 178 178 + 179 179 + var file_rockbox_search_v1alpha1_artist_proto_msgTypes = make([]protoimpl.MessageInfo, 2) 180 180 + var file_rockbox_search_v1alpha1_artist_proto_goTypes = []interface{}{ 181 181 + (*Artist)(nil), // 0: rockbox.search.v1alpha1.Artist 182 182 + (*ArtistList)(nil), // 1: rockbox.search.v1alpha1.ArtistList 183 183 + } 184 184 + var file_rockbox_search_v1alpha1_artist_proto_depIdxs = []int32{ 185 185 + 0, // 0: rockbox.search.v1alpha1.ArtistList.artists:type_name -> rockbox.search.v1alpha1.Artist 186 186 + 1, // [1:1] is the sub-list for method output_type 187 187 + 1, // [1:1] is the sub-list for method input_type 188 188 + 1, // [1:1] is the sub-list for extension type_name 189 189 + 1, // [1:1] is the sub-list for extension extendee 190 190 + 0, // [0:1] is the sub-list for field type_name 191 191 + } 192 192 + 193 193 + func init() { file_rockbox_search_v1alpha1_artist_proto_init() } 194 194 + func file_rockbox_search_v1alpha1_artist_proto_init() { 195 195 + if File_rockbox_search_v1alpha1_artist_proto != nil { 196 196 + return 197 197 + } 198 198 + if !protoimpl.UnsafeEnabled { 199 199 + file_rockbox_search_v1alpha1_artist_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { 200 200 + switch v := v.(*Artist); i { 201 201 + case 0: 202 202 + return &v.state 203 203 + case 1: 204 204 + return &v.sizeCache 205 205 + case 2: 206 206 + return &v.unknownFields 207 207 + default: 208 208 + return nil 209 209 + } 210 210 + } 211 211 + file_rockbox_search_v1alpha1_artist_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { 212 212 + switch v := v.(*ArtistList); i { 213 213 + case 0: 214 214 + return &v.state 215 215 + case 1: 216 216 + return &v.sizeCache 217 217 + case 2: 218 218 + return &v.unknownFields 219 219 + default: 220 220 + return nil 221 221 + } 222 222 + } 223 223 + } 224 224 + file_rockbox_search_v1alpha1_artist_proto_msgTypes[0].OneofWrappers = []interface{}{} 225 225 + type x struct{} 226 226 + out := protoimpl.TypeBuilder{ 227 227 + File: protoimpl.DescBuilder{ 228 228 + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), 229 229 + RawDescriptor: file_rockbox_search_v1alpha1_artist_proto_rawDesc, 230 230 + NumEnums: 0, 231 231 + NumMessages: 2, 232 232 + NumExtensions: 0, 233 233 + NumServices: 0, 234 234 + }, 235 235 + GoTypes: file_rockbox_search_v1alpha1_artist_proto_goTypes, 236 236 + DependencyIndexes: file_rockbox_search_v1alpha1_artist_proto_depIdxs, 237 237 + MessageInfos: file_rockbox_search_v1alpha1_artist_proto_msgTypes, 238 238 + }.Build() 239 239 + File_rockbox_search_v1alpha1_artist_proto = out.File 240 240 + file_rockbox_search_v1alpha1_artist_proto_rawDesc = nil 241 241 + file_rockbox_search_v1alpha1_artist_proto_goTypes = nil 242 242 + file_rockbox_search_v1alpha1_artist_proto_depIdxs = nil 243 243 + }

+241

search/gen/rockbox/search/v1alpha1/file.pb.go

··· 1 1 + // Code generated by protoc-gen-go. DO NOT EDIT. 2 2 + // versions: 3 3 + // protoc-gen-go v1.31.0 4 4 + // protoc (unknown) 5 5 + // source: rockbox/search/v1alpha1/file.proto 6 6 + 7 7 + package v1alpha1 8 8 + 9 9 + import ( 10 10 + protoreflect "google.golang.org/protobuf/reflect/protoreflect" 11 11 + protoimpl "google.golang.org/protobuf/runtime/protoimpl" 12 12 + reflect "reflect" 13 13 + sync "sync" 14 14 + ) 15 15 + 16 16 + const ( 17 17 + // Verify that this generated code is sufficiently up-to-date. 18 18 + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) 19 19 + // Verify that runtime/protoimpl is sufficiently up-to-date. 20 20 + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) 21 21 + ) 22 22 + 23 23 + type File struct { 24 24 + state protoimpl.MessageState 25 25 + sizeCache protoimpl.SizeCache 26 26 + unknownFields protoimpl.UnknownFields 27 27 + 28 28 + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 29 29 + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` 30 30 + TimeWrite uint32 `protobuf:"varint,4,opt,name=time_write,json=timeWrite,proto3" json:"time_write,omitempty"` 31 31 + IsDirectory bool `protobuf:"varint,5,opt,name=is_directory,json=isDirectory,proto3" json:"is_directory,omitempty"` 32 32 + } 33 33 + 34 34 + func (x *File) Reset() { 35 35 + *x = File{} 36 36 + if protoimpl.UnsafeEnabled { 37 37 + mi := &file_rockbox_search_v1alpha1_file_proto_msgTypes[0] 38 38 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 39 39 + ms.StoreMessageInfo(mi) 40 40 + } 41 41 + } 42 42 + 43 43 + func (x *File) String() string { 44 44 + return protoimpl.X.MessageStringOf(x) 45 45 + } 46 46 + 47 47 + func (*File) ProtoMessage() {} 48 48 + 49 49 + func (x *File) ProtoReflect() protoreflect.Message { 50 50 + mi := &file_rockbox_search_v1alpha1_file_proto_msgTypes[0] 51 51 + if protoimpl.UnsafeEnabled && x != nil { 52 52 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 53 53 + if ms.LoadMessageInfo() == nil { 54 54 + ms.StoreMessageInfo(mi) 55 55 + } 56 56 + return ms 57 57 + } 58 58 + return mi.MessageOf(x) 59 59 + } 60 60 + 61 61 + // Deprecated: Use File.ProtoReflect.Descriptor instead. 62 62 + func (*File) Descriptor() ([]byte, []int) { 63 63 + return file_rockbox_search_v1alpha1_file_proto_rawDescGZIP(), []int{0} 64 64 + } 65 65 + 66 66 + func (x *File) GetId() string { 67 67 + if x != nil { 68 68 + return x.Id 69 69 + } 70 70 + return "" 71 71 + } 72 72 + 73 73 + func (x *File) GetName() string { 74 74 + if x != nil { 75 75 + return x.Name 76 76 + } 77 77 + return "" 78 78 + } 79 79 + 80 80 + func (x *File) GetTimeWrite() uint32 { 81 81 + if x != nil { 82 82 + return x.TimeWrite 83 83 + } 84 84 + return 0 85 85 + } 86 86 + 87 87 + func (x *File) GetIsDirectory() bool { 88 88 + if x != nil { 89 89 + return x.IsDirectory 90 90 + } 91 91 + return false 92 92 + } 93 93 + 94 94 + type FileList struct { 95 95 + state protoimpl.MessageState 96 96 + sizeCache protoimpl.SizeCache 97 97 + unknownFields protoimpl.UnknownFields 98 98 + 99 99 + Files []*File `protobuf:"bytes,1,rep,name=files,proto3" json:"files,omitempty"` 100 100 + } 101 101 + 102 102 + func (x *FileList) Reset() { 103 103 + *x = FileList{} 104 104 + if protoimpl.UnsafeEnabled { 105 105 + mi := &file_rockbox_search_v1alpha1_file_proto_msgTypes[1] 106 106 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 107 107 + ms.StoreMessageInfo(mi) 108 108 + } 109 109 + } 110 110 + 111 111 + func (x *FileList) String() string { 112 112 + return protoimpl.X.MessageStringOf(x) 113 113 + } 114 114 + 115 115 + func (*FileList) ProtoMessage() {} 116 116 + 117 117 + func (x *FileList) ProtoReflect() protoreflect.Message { 118 118 + mi := &file_rockbox_search_v1alpha1_file_proto_msgTypes[1] 119 119 + if protoimpl.UnsafeEnabled && x != nil { 120 120 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 121 121 + if ms.LoadMessageInfo() == nil { 122 122 + ms.StoreMessageInfo(mi) 123 123 + } 124 124 + return ms 125 125 + } 126 126 + return mi.MessageOf(x) 127 127 + } 128 128 + 129 129 + // Deprecated: Use FileList.ProtoReflect.Descriptor instead. 130 130 + func (*FileList) Descriptor() ([]byte, []int) { 131 131 + return file_rockbox_search_v1alpha1_file_proto_rawDescGZIP(), []int{1} 132 132 + } 133 133 + 134 134 + func (x *FileList) GetFiles() []*File { 135 135 + if x != nil { 136 136 + return x.Files 137 137 + } 138 138 + return nil 139 139 + } 140 140 + 141 141 + var File_rockbox_search_v1alpha1_file_proto protoreflect.FileDescriptor 142 142 + 143 143 + var file_rockbox_search_v1alpha1_file_proto_rawDesc = []byte{ 144 144 + 0x0a, 0x22, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2f, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 145 145 + 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x66, 0x69, 0x6c, 0x65, 0x2e, 0x70, 146 146 + 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x17, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2e, 0x73, 0x65, 147 147 + 0x61, 0x72, 0x63, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x22, 0x6c, 0x0a, 148 148 + 0x04, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 149 149 + 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 150 150 + 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x69, 0x6d, 151 151 + 0x65, 0x5f, 0x77, 0x72, 0x69, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x74, 152 152 + 0x69, 0x6d, 0x65, 0x57, 0x72, 0x69, 0x74, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x73, 0x5f, 0x64, 153 153 + 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 154 154 + 0x69, 0x73, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x79, 0x22, 0x3f, 0x0a, 0x08, 0x46, 155 155 + 0x69, 0x6c, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x33, 0x0a, 0x05, 0x66, 0x69, 0x6c, 0x65, 0x73, 156 156 + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 157 157 + 0x2e, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 158 158 + 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x52, 0x05, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x42, 0x3e, 0x5a, 0x3c, 159 159 + 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x74, 0x73, 0x69, 0x72, 0x79, 160 160 + 0x73, 0x6e, 0x64, 0x72, 0x2f, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2d, 0x7a, 0x69, 0x67, 161 161 + 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2f, 0x73, 0x65, 0x61, 162 162 + 0x72, 0x63, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 163 163 + 0x6f, 0x74, 0x6f, 0x33, 164 164 + } 165 165 + 166 166 + var ( 167 167 + file_rockbox_search_v1alpha1_file_proto_rawDescOnce sync.Once 168 168 + file_rockbox_search_v1alpha1_file_proto_rawDescData = file_rockbox_search_v1alpha1_file_proto_rawDesc 169 169 + ) 170 170 + 171 171 + func file_rockbox_search_v1alpha1_file_proto_rawDescGZIP() []byte { 172 172 + file_rockbox_search_v1alpha1_file_proto_rawDescOnce.Do(func() { 173 173 + file_rockbox_search_v1alpha1_file_proto_rawDescData = protoimpl.X.CompressGZIP(file_rockbox_search_v1alpha1_file_proto_rawDescData) 174 174 + }) 175 175 + return file_rockbox_search_v1alpha1_file_proto_rawDescData 176 176 + } 177 177 + 178 178 + var file_rockbox_search_v1alpha1_file_proto_msgTypes = make([]protoimpl.MessageInfo, 2) 179 179 + var file_rockbox_search_v1alpha1_file_proto_goTypes = []interface{}{ 180 180 + (*File)(nil), // 0: rockbox.search.v1alpha1.File 181 181 + (*FileList)(nil), // 1: rockbox.search.v1alpha1.FileList 182 182 + } 183 183 + var file_rockbox_search_v1alpha1_file_proto_depIdxs = []int32{ 184 184 + 0, // 0: rockbox.search.v1alpha1.FileList.files:type_name -> rockbox.search.v1alpha1.File 185 185 + 1, // [1:1] is the sub-list for method output_type 186 186 + 1, // [1:1] is the sub-list for method input_type 187 187 + 1, // [1:1] is the sub-list for extension type_name 188 188 + 1, // [1:1] is the sub-list for extension extendee 189 189 + 0, // [0:1] is the sub-list for field type_name 190 190 + } 191 191 + 192 192 + func init() { file_rockbox_search_v1alpha1_file_proto_init() } 193 193 + func file_rockbox_search_v1alpha1_file_proto_init() { 194 194 + if File_rockbox_search_v1alpha1_file_proto != nil { 195 195 + return 196 196 + } 197 197 + if !protoimpl.UnsafeEnabled { 198 198 + file_rockbox_search_v1alpha1_file_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { 199 199 + switch v := v.(*File); i { 200 200 + case 0: 201 201 + return &v.state 202 202 + case 1: 203 203 + return &v.sizeCache 204 204 + case 2: 205 205 + return &v.unknownFields 206 206 + default: 207 207 + return nil 208 208 + } 209 209 + } 210 210 + file_rockbox_search_v1alpha1_file_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { 211 211 + switch v := v.(*FileList); i { 212 212 + case 0: 213 213 + return &v.state 214 214 + case 1: 215 215 + return &v.sizeCache 216 216 + case 2: 217 217 + return &v.unknownFields 218 218 + default: 219 219 + return nil 220 220 + } 221 221 + } 222 222 + } 223 223 + type x struct{} 224 224 + out := protoimpl.TypeBuilder{ 225 225 + File: protoimpl.DescBuilder{ 226 226 + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), 227 227 + RawDescriptor: file_rockbox_search_v1alpha1_file_proto_rawDesc, 228 228 + NumEnums: 0, 229 229 + NumMessages: 2, 230 230 + NumExtensions: 0, 231 231 + NumServices: 0, 232 232 + }, 233 233 + GoTypes: file_rockbox_search_v1alpha1_file_proto_goTypes, 234 234 + DependencyIndexes: file_rockbox_search_v1alpha1_file_proto_depIdxs, 235 235 + MessageInfos: file_rockbox_search_v1alpha1_file_proto_msgTypes, 236 236 + }.Build() 237 237 + File_rockbox_search_v1alpha1_file_proto = out.File 238 238 + file_rockbox_search_v1alpha1_file_proto_rawDesc = nil 239 239 + file_rockbox_search_v1alpha1_file_proto_goTypes = nil 240 240 + file_rockbox_search_v1alpha1_file_proto_depIdxs = nil 241 241 + }

+628

search/gen/rockbox/search/v1alpha1/like.pb.go

··· 1 1 + // Code generated by protoc-gen-go. DO NOT EDIT. 2 2 + // versions: 3 3 + // protoc-gen-go v1.31.0 4 4 + // protoc (unknown) 5 5 + // source: rockbox/search/v1alpha1/like.proto 6 6 + 7 7 + package v1alpha1 8 8 + 9 9 + import ( 10 10 + protoreflect "google.golang.org/protobuf/reflect/protoreflect" 11 11 + protoimpl "google.golang.org/protobuf/runtime/protoimpl" 12 12 + reflect "reflect" 13 13 + sync "sync" 14 14 + ) 15 15 + 16 16 + const ( 17 17 + // Verify that this generated code is sufficiently up-to-date. 18 18 + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) 19 19 + // Verify that runtime/protoimpl is sufficiently up-to-date. 20 20 + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) 21 21 + ) 22 22 + 23 23 + type LikedAlbum struct { 24 24 + state protoimpl.MessageState 25 25 + sizeCache protoimpl.SizeCache 26 26 + unknownFields protoimpl.UnknownFields 27 27 + 28 28 + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 29 29 + Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"` 30 30 + Artist string `protobuf:"bytes,3,opt,name=artist,proto3" json:"artist,omitempty"` 31 31 + Year uint32 `protobuf:"varint,4,opt,name=year,proto3" json:"year,omitempty"` 32 32 + YearString string `protobuf:"bytes,5,opt,name=year_string,json=yearString,proto3" json:"year_string,omitempty"` 33 33 + AlbumArt *string `protobuf:"bytes,6,opt,name=album_art,json=albumArt,proto3,oneof" json:"album_art,omitempty"` 34 34 + Md5 string `protobuf:"bytes,7,opt,name=md5,proto3" json:"md5,omitempty"` 35 35 + ArtistId string `protobuf:"bytes,8,opt,name=artist_id,json=artistId,proto3" json:"artist_id,omitempty"` 36 36 + } 37 37 + 38 38 + func (x *LikedAlbum) Reset() { 39 39 + *x = LikedAlbum{} 40 40 + if protoimpl.UnsafeEnabled { 41 41 + mi := &file_rockbox_search_v1alpha1_like_proto_msgTypes[0] 42 42 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 43 43 + ms.StoreMessageInfo(mi) 44 44 + } 45 45 + } 46 46 + 47 47 + func (x *LikedAlbum) String() string { 48 48 + return protoimpl.X.MessageStringOf(x) 49 49 + } 50 50 + 51 51 + func (*LikedAlbum) ProtoMessage() {} 52 52 + 53 53 + func (x *LikedAlbum) ProtoReflect() protoreflect.Message { 54 54 + mi := &file_rockbox_search_v1alpha1_like_proto_msgTypes[0] 55 55 + if protoimpl.UnsafeEnabled && x != nil { 56 56 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 57 57 + if ms.LoadMessageInfo() == nil { 58 58 + ms.StoreMessageInfo(mi) 59 59 + } 60 60 + return ms 61 61 + } 62 62 + return mi.MessageOf(x) 63 63 + } 64 64 + 65 65 + // Deprecated: Use LikedAlbum.ProtoReflect.Descriptor instead. 66 66 + func (*LikedAlbum) Descriptor() ([]byte, []int) { 67 67 + return file_rockbox_search_v1alpha1_like_proto_rawDescGZIP(), []int{0} 68 68 + } 69 69 + 70 70 + func (x *LikedAlbum) GetId() string { 71 71 + if x != nil { 72 72 + return x.Id 73 73 + } 74 74 + return "" 75 75 + } 76 76 + 77 77 + func (x *LikedAlbum) GetTitle() string { 78 78 + if x != nil { 79 79 + return x.Title 80 80 + } 81 81 + return "" 82 82 + } 83 83 + 84 84 + func (x *LikedAlbum) GetArtist() string { 85 85 + if x != nil { 86 86 + return x.Artist 87 87 + } 88 88 + return "" 89 89 + } 90 90 + 91 91 + func (x *LikedAlbum) GetYear() uint32 { 92 92 + if x != nil { 93 93 + return x.Year 94 94 + } 95 95 + return 0 96 96 + } 97 97 + 98 98 + func (x *LikedAlbum) GetYearString() string { 99 99 + if x != nil { 100 100 + return x.YearString 101 101 + } 102 102 + return "" 103 103 + } 104 104 + 105 105 + func (x *LikedAlbum) GetAlbumArt() string { 106 106 + if x != nil && x.AlbumArt != nil { 107 107 + return *x.AlbumArt 108 108 + } 109 109 + return "" 110 110 + } 111 111 + 112 112 + func (x *LikedAlbum) GetMd5() string { 113 113 + if x != nil { 114 114 + return x.Md5 115 115 + } 116 116 + return "" 117 117 + } 118 118 + 119 119 + func (x *LikedAlbum) GetArtistId() string { 120 120 + if x != nil { 121 121 + return x.ArtistId 122 122 + } 123 123 + return "" 124 124 + } 125 125 + 126 126 + type LikedTrack struct { 127 127 + state protoimpl.MessageState 128 128 + sizeCache protoimpl.SizeCache 129 129 + unknownFields protoimpl.UnknownFields 130 130 + 131 131 + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 132 132 + Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"` 133 133 + Title string `protobuf:"bytes,3,opt,name=title,proto3" json:"title,omitempty"` 134 134 + Artist string `protobuf:"bytes,4,opt,name=artist,proto3" json:"artist,omitempty"` 135 135 + Album string `protobuf:"bytes,5,opt,name=album,proto3" json:"album,omitempty"` 136 136 + AlbumArtist string `protobuf:"bytes,6,opt,name=album_artist,json=albumArtist,proto3" json:"album_artist,omitempty"` 137 137 + Bitrate uint32 `protobuf:"varint,7,opt,name=bitrate,proto3" json:"bitrate,omitempty"` 138 138 + Composer string `protobuf:"bytes,8,opt,name=composer,proto3" json:"composer,omitempty"` 139 139 + DiscNumber uint32 `protobuf:"varint,9,opt,name=disc_number,json=discNumber,proto3" json:"disc_number,omitempty"` 140 140 + Filesize uint32 `protobuf:"varint,10,opt,name=filesize,proto3" json:"filesize,omitempty"` 141 141 + Frequency uint32 `protobuf:"varint,11,opt,name=frequency,proto3" json:"frequency,omitempty"` 142 142 + Length uint32 `protobuf:"varint,12,opt,name=length,proto3" json:"length,omitempty"` 143 143 + TrackNumber uint32 `protobuf:"varint,13,opt,name=track_number,json=trackNumber,proto3" json:"track_number,omitempty"` 144 144 + Year uint32 `protobuf:"varint,14,opt,name=year,proto3" json:"year,omitempty"` 145 145 + YearString string `protobuf:"bytes,15,opt,name=year_string,json=yearString,proto3" json:"year_string,omitempty"` 146 146 + Genre string `protobuf:"bytes,16,opt,name=genre,proto3" json:"genre,omitempty"` 147 147 + Md5 string `protobuf:"bytes,17,opt,name=md5,proto3" json:"md5,omitempty"` 148 148 + AlbumArt *string `protobuf:"bytes,18,opt,name=album_art,json=albumArt,proto3,oneof" json:"album_art,omitempty"` 149 149 + ArtistId *string `protobuf:"bytes,19,opt,name=artist_id,json=artistId,proto3,oneof" json:"artist_id,omitempty"` 150 150 + AlbumId *string `protobuf:"bytes,20,opt,name=album_id,json=albumId,proto3,oneof" json:"album_id,omitempty"` 151 151 + GenreId *string `protobuf:"bytes,21,opt,name=genre_id,json=genreId,proto3,oneof" json:"genre_id,omitempty"` 152 152 + CreatedAt string `protobuf:"bytes,22,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` 153 153 + UpdatedAt string `protobuf:"bytes,23,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"` 154 154 + } 155 155 + 156 156 + func (x *LikedTrack) Reset() { 157 157 + *x = LikedTrack{} 158 158 + if protoimpl.UnsafeEnabled { 159 159 + mi := &file_rockbox_search_v1alpha1_like_proto_msgTypes[1] 160 160 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 161 161 + ms.StoreMessageInfo(mi) 162 162 + } 163 163 + } 164 164 + 165 165 + func (x *LikedTrack) String() string { 166 166 + return protoimpl.X.MessageStringOf(x) 167 167 + } 168 168 + 169 169 + func (*LikedTrack) ProtoMessage() {} 170 170 + 171 171 + func (x *LikedTrack) ProtoReflect() protoreflect.Message { 172 172 + mi := &file_rockbox_search_v1alpha1_like_proto_msgTypes[1] 173 173 + if protoimpl.UnsafeEnabled && x != nil { 174 174 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 175 175 + if ms.LoadMessageInfo() == nil { 176 176 + ms.StoreMessageInfo(mi) 177 177 + } 178 178 + return ms 179 179 + } 180 180 + return mi.MessageOf(x) 181 181 + } 182 182 + 183 183 + // Deprecated: Use LikedTrack.ProtoReflect.Descriptor instead. 184 184 + func (*LikedTrack) Descriptor() ([]byte, []int) { 185 185 + return file_rockbox_search_v1alpha1_like_proto_rawDescGZIP(), []int{1} 186 186 + } 187 187 + 188 188 + func (x *LikedTrack) GetId() string { 189 189 + if x != nil { 190 190 + return x.Id 191 191 + } 192 192 + return "" 193 193 + } 194 194 + 195 195 + func (x *LikedTrack) GetPath() string { 196 196 + if x != nil { 197 197 + return x.Path 198 198 + } 199 199 + return "" 200 200 + } 201 201 + 202 202 + func (x *LikedTrack) GetTitle() string { 203 203 + if x != nil { 204 204 + return x.Title 205 205 + } 206 206 + return "" 207 207 + } 208 208 + 209 209 + func (x *LikedTrack) GetArtist() string { 210 210 + if x != nil { 211 211 + return x.Artist 212 212 + } 213 213 + return "" 214 214 + } 215 215 + 216 216 + func (x *LikedTrack) GetAlbum() string { 217 217 + if x != nil { 218 218 + return x.Album 219 219 + } 220 220 + return "" 221 221 + } 222 222 + 223 223 + func (x *LikedTrack) GetAlbumArtist() string { 224 224 + if x != nil { 225 225 + return x.AlbumArtist 226 226 + } 227 227 + return "" 228 228 + } 229 229 + 230 230 + func (x *LikedTrack) GetBitrate() uint32 { 231 231 + if x != nil { 232 232 + return x.Bitrate 233 233 + } 234 234 + return 0 235 235 + } 236 236 + 237 237 + func (x *LikedTrack) GetComposer() string { 238 238 + if x != nil { 239 239 + return x.Composer 240 240 + } 241 241 + return "" 242 242 + } 243 243 + 244 244 + func (x *LikedTrack) GetDiscNumber() uint32 { 245 245 + if x != nil { 246 246 + return x.DiscNumber 247 247 + } 248 248 + return 0 249 249 + } 250 250 + 251 251 + func (x *LikedTrack) GetFilesize() uint32 { 252 252 + if x != nil { 253 253 + return x.Filesize 254 254 + } 255 255 + return 0 256 256 + } 257 257 + 258 258 + func (x *LikedTrack) GetFrequency() uint32 { 259 259 + if x != nil { 260 260 + return x.Frequency 261 261 + } 262 262 + return 0 263 263 + } 264 264 + 265 265 + func (x *LikedTrack) GetLength() uint32 { 266 266 + if x != nil { 267 267 + return x.Length 268 268 + } 269 269 + return 0 270 270 + } 271 271 + 272 272 + func (x *LikedTrack) GetTrackNumber() uint32 { 273 273 + if x != nil { 274 274 + return x.TrackNumber 275 275 + } 276 276 + return 0 277 277 + } 278 278 + 279 279 + func (x *LikedTrack) GetYear() uint32 { 280 280 + if x != nil { 281 281 + return x.Year 282 282 + } 283 283 + return 0 284 284 + } 285 285 + 286 286 + func (x *LikedTrack) GetYearString() string { 287 287 + if x != nil { 288 288 + return x.YearString 289 289 + } 290 290 + return "" 291 291 + } 292 292 + 293 293 + func (x *LikedTrack) GetGenre() string { 294 294 + if x != nil { 295 295 + return x.Genre 296 296 + } 297 297 + return "" 298 298 + } 299 299 + 300 300 + func (x *LikedTrack) GetMd5() string { 301 301 + if x != nil { 302 302 + return x.Md5 303 303 + } 304 304 + return "" 305 305 + } 306 306 + 307 307 + func (x *LikedTrack) GetAlbumArt() string { 308 308 + if x != nil && x.AlbumArt != nil { 309 309 + return *x.AlbumArt 310 310 + } 311 311 + return "" 312 312 + } 313 313 + 314 314 + func (x *LikedTrack) GetArtistId() string { 315 315 + if x != nil && x.ArtistId != nil { 316 316 + return *x.ArtistId 317 317 + } 318 318 + return "" 319 319 + } 320 320 + 321 321 + func (x *LikedTrack) GetAlbumId() string { 322 322 + if x != nil && x.AlbumId != nil { 323 323 + return *x.AlbumId 324 324 + } 325 325 + return "" 326 326 + } 327 327 + 328 328 + func (x *LikedTrack) GetGenreId() string { 329 329 + if x != nil && x.GenreId != nil { 330 330 + return *x.GenreId 331 331 + } 332 332 + return "" 333 333 + } 334 334 + 335 335 + func (x *LikedTrack) GetCreatedAt() string { 336 336 + if x != nil { 337 337 + return x.CreatedAt 338 338 + } 339 339 + return "" 340 340 + } 341 341 + 342 342 + func (x *LikedTrack) GetUpdatedAt() string { 343 343 + if x != nil { 344 344 + return x.UpdatedAt 345 345 + } 346 346 + return "" 347 347 + } 348 348 + 349 349 + type LikedAlbumList struct { 350 350 + state protoimpl.MessageState 351 351 + sizeCache protoimpl.SizeCache 352 352 + unknownFields protoimpl.UnknownFields 353 353 + 354 354 + Albums []*LikedAlbum `protobuf:"bytes,1,rep,name=albums,proto3" json:"albums,omitempty"` 355 355 + } 356 356 + 357 357 + func (x *LikedAlbumList) Reset() { 358 358 + *x = LikedAlbumList{} 359 359 + if protoimpl.UnsafeEnabled { 360 360 + mi := &file_rockbox_search_v1alpha1_like_proto_msgTypes[2] 361 361 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 362 362 + ms.StoreMessageInfo(mi) 363 363 + } 364 364 + } 365 365 + 366 366 + func (x *LikedAlbumList) String() string { 367 367 + return protoimpl.X.MessageStringOf(x) 368 368 + } 369 369 + 370 370 + func (*LikedAlbumList) ProtoMessage() {} 371 371 + 372 372 + func (x *LikedAlbumList) ProtoReflect() protoreflect.Message { 373 373 + mi := &file_rockbox_search_v1alpha1_like_proto_msgTypes[2] 374 374 + if protoimpl.UnsafeEnabled && x != nil { 375 375 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 376 376 + if ms.LoadMessageInfo() == nil { 377 377 + ms.StoreMessageInfo(mi) 378 378 + } 379 379 + return ms 380 380 + } 381 381 + return mi.MessageOf(x) 382 382 + } 383 383 + 384 384 + // Deprecated: Use LikedAlbumList.ProtoReflect.Descriptor instead. 385 385 + func (*LikedAlbumList) Descriptor() ([]byte, []int) { 386 386 + return file_rockbox_search_v1alpha1_like_proto_rawDescGZIP(), []int{2} 387 387 + } 388 388 + 389 389 + func (x *LikedAlbumList) GetAlbums() []*LikedAlbum { 390 390 + if x != nil { 391 391 + return x.Albums 392 392 + } 393 393 + return nil 394 394 + } 395 395 + 396 396 + type LikedTrackList struct { 397 397 + state protoimpl.MessageState 398 398 + sizeCache protoimpl.SizeCache 399 399 + unknownFields protoimpl.UnknownFields 400 400 + 401 401 + Tracks []*LikedTrack `protobuf:"bytes,1,rep,name=tracks,proto3" json:"tracks,omitempty"` 402 402 + } 403 403 + 404 404 + func (x *LikedTrackList) Reset() { 405 405 + *x = LikedTrackList{} 406 406 + if protoimpl.UnsafeEnabled { 407 407 + mi := &file_rockbox_search_v1alpha1_like_proto_msgTypes[3] 408 408 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 409 409 + ms.StoreMessageInfo(mi) 410 410 + } 411 411 + } 412 412 + 413 413 + func (x *LikedTrackList) String() string { 414 414 + return protoimpl.X.MessageStringOf(x) 415 415 + } 416 416 + 417 417 + func (*LikedTrackList) ProtoMessage() {} 418 418 + 419 419 + func (x *LikedTrackList) ProtoReflect() protoreflect.Message { 420 420 + mi := &file_rockbox_search_v1alpha1_like_proto_msgTypes[3] 421 421 + if protoimpl.UnsafeEnabled && x != nil { 422 422 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 423 423 + if ms.LoadMessageInfo() == nil { 424 424 + ms.StoreMessageInfo(mi) 425 425 + } 426 426 + return ms 427 427 + } 428 428 + return mi.MessageOf(x) 429 429 + } 430 430 + 431 431 + // Deprecated: Use LikedTrackList.ProtoReflect.Descriptor instead. 432 432 + func (*LikedTrackList) Descriptor() ([]byte, []int) { 433 433 + return file_rockbox_search_v1alpha1_like_proto_rawDescGZIP(), []int{3} 434 434 + } 435 435 + 436 436 + func (x *LikedTrackList) GetTracks() []*LikedTrack { 437 437 + if x != nil { 438 438 + return x.Tracks 439 439 + } 440 440 + return nil 441 441 + } 442 442 + 443 443 + var File_rockbox_search_v1alpha1_like_proto protoreflect.FileDescriptor 444 444 + 445 445 + var file_rockbox_search_v1alpha1_like_proto_rawDesc = []byte{ 446 446 + 0x0a, 0x22, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2f, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 447 447 + 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6c, 0x69, 0x6b, 0x65, 0x2e, 0x70, 448 448 + 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x17, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2e, 0x73, 0x65, 449 449 + 0x61, 0x72, 0x63, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x22, 0xde, 0x01, 450 450 + 0x0a, 0x0a, 0x4c, 0x69, 0x6b, 0x65, 0x64, 0x41, 0x6c, 0x62, 0x75, 0x6d, 0x12, 0x0e, 0x0a, 0x02, 451 451 + 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x14, 0x0a, 0x05, 452 452 + 0x74, 0x69, 0x74, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x69, 0x74, 453 453 + 0x6c, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x18, 0x03, 0x20, 0x01, 454 454 + 0x28, 0x09, 0x52, 0x06, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x79, 0x65, 455 455 + 0x61, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x79, 0x65, 0x61, 0x72, 0x12, 0x1f, 456 456 + 0x0a, 0x0b, 0x79, 0x65, 0x61, 0x72, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x05, 0x20, 457 457 + 0x01, 0x28, 0x09, 0x52, 0x0a, 0x79, 0x65, 0x61, 0x72, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 458 458 + 0x20, 0x0a, 0x09, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x5f, 0x61, 0x72, 0x74, 0x18, 0x06, 0x20, 0x01, 459 459 + 0x28, 0x09, 0x48, 0x00, 0x52, 0x08, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x41, 0x72, 0x74, 0x88, 0x01, 460 460 + 0x01, 0x12, 0x10, 0x0a, 0x03, 0x6d, 0x64, 0x35, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 461 461 + 0x6d, 0x64, 0x35, 0x12, 0x1b, 0x0a, 0x09, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x5f, 0x69, 0x64, 462 462 + 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x49, 0x64, 463 463 + 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x5f, 0x61, 0x72, 0x74, 0x22, 0xb8, 464 464 + 0x05, 0x0a, 0x0a, 0x4c, 0x69, 0x6b, 0x65, 0x64, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x12, 0x0e, 0x0a, 465 465 + 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 466 466 + 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 467 467 + 0x68, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 468 468 + 0x52, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x72, 0x74, 0x69, 0x73, 469 469 + 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x12, 470 470 + 0x14, 0x0a, 0x05, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 471 471 + 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x5f, 0x61, 472 472 + 0x72, 0x74, 0x69, 0x73, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x6c, 0x62, 473 473 + 0x75, 0x6d, 0x41, 0x72, 0x74, 0x69, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x62, 0x69, 0x74, 0x72, 474 474 + 0x61, 0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x62, 0x69, 0x74, 0x72, 0x61, 475 475 + 0x74, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x18, 0x08, 476 476 + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x12, 0x1f, 477 477 + 0x0a, 0x0b, 0x64, 0x69, 0x73, 0x63, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x09, 0x20, 478 478 + 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x64, 0x69, 0x73, 0x63, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 479 479 + 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 480 480 + 0x0d, 0x52, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x69, 0x7a, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x66, 481 481 + 0x72, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 482 482 + 0x66, 0x72, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x6c, 0x65, 0x6e, 483 483 + 0x67, 0x74, 0x68, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x6c, 0x65, 0x6e, 0x67, 0x74, 484 484 + 0x68, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 485 485 + 0x72, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x4e, 0x75, 486 486 + 0x6d, 0x62, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x79, 0x65, 0x61, 0x72, 0x18, 0x0e, 0x20, 0x01, 487 487 + 0x28, 0x0d, 0x52, 0x04, 0x79, 0x65, 0x61, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x79, 0x65, 0x61, 0x72, 488 488 + 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x79, 489 489 + 0x65, 0x61, 0x72, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x14, 0x0a, 0x05, 0x67, 0x65, 0x6e, 490 490 + 0x72, 0x65, 0x18, 0x10, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x67, 0x65, 0x6e, 0x72, 0x65, 0x12, 491 491 + 0x10, 0x0a, 0x03, 0x6d, 0x64, 0x35, 0x18, 0x11, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6d, 0x64, 492 492 + 0x35, 0x12, 0x20, 0x0a, 0x09, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x5f, 0x61, 0x72, 0x74, 0x18, 0x12, 493 493 + 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x08, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x41, 0x72, 0x74, 494 494 + 0x88, 0x01, 0x01, 0x12, 0x20, 0x0a, 0x09, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x5f, 0x69, 0x64, 495 495 + 0x18, 0x13, 0x20, 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x08, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 496 496 + 0x49, 0x64, 0x88, 0x01, 0x01, 0x12, 0x1e, 0x0a, 0x08, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x5f, 0x69, 497 497 + 0x64, 0x18, 0x14, 0x20, 0x01, 0x28, 0x09, 0x48, 0x02, 0x52, 0x07, 0x61, 0x6c, 0x62, 0x75, 0x6d, 498 498 + 0x49, 0x64, 0x88, 0x01, 0x01, 0x12, 0x1e, 0x0a, 0x08, 0x67, 0x65, 0x6e, 0x72, 0x65, 0x5f, 0x69, 499 499 + 0x64, 0x18, 0x15, 0x20, 0x01, 0x28, 0x09, 0x48, 0x03, 0x52, 0x07, 0x67, 0x65, 0x6e, 0x72, 0x65, 500 500 + 0x49, 0x64, 0x88, 0x01, 0x01, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 501 501 + 0x5f, 0x61, 0x74, 0x18, 0x16, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 502 502 + 0x65, 0x64, 0x41, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 503 503 + 0x61, 0x74, 0x18, 0x17, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 504 504 + 0x64, 0x41, 0x74, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x5f, 0x61, 0x72, 505 505 + 0x74, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x42, 506 506 + 0x0b, 0x0a, 0x09, 0x5f, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x5f, 0x69, 0x64, 0x42, 0x0b, 0x0a, 0x09, 507 507 + 0x5f, 0x67, 0x65, 0x6e, 0x72, 0x65, 0x5f, 0x69, 0x64, 0x22, 0x4d, 0x0a, 0x0e, 0x4c, 0x69, 0x6b, 508 508 + 0x65, 0x64, 0x41, 0x6c, 0x62, 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x3b, 0x0a, 0x06, 0x61, 509 509 + 0x6c, 0x62, 0x75, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x72, 0x6f, 510 510 + 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2e, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2e, 0x76, 0x31, 0x61, 511 511 + 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x6b, 0x65, 0x64, 0x41, 0x6c, 0x62, 0x75, 0x6d, 512 512 + 0x52, 0x06, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x73, 0x22, 0x4d, 0x0a, 0x0e, 0x4c, 0x69, 0x6b, 0x65, 513 513 + 0x64, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x3b, 0x0a, 0x06, 0x74, 0x72, 514 514 + 0x61, 0x63, 0x6b, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x72, 0x6f, 0x63, 515 515 + 0x6b, 0x62, 0x6f, 0x78, 0x2e, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 516 516 + 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x6b, 0x65, 0x64, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x52, 517 517 + 0x06, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x73, 0x42, 0x3e, 0x5a, 0x3c, 0x67, 0x69, 0x74, 0x68, 0x75, 518 518 + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x74, 0x73, 0x69, 0x72, 0x79, 0x73, 0x6e, 0x64, 0x72, 0x2f, 519 519 + 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2d, 0x7a, 0x69, 0x67, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 520 520 + 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2f, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2f, 0x76, 521 521 + 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 522 522 + } 523 523 + 524 524 + var ( 525 525 + file_rockbox_search_v1alpha1_like_proto_rawDescOnce sync.Once 526 526 + file_rockbox_search_v1alpha1_like_proto_rawDescData = file_rockbox_search_v1alpha1_like_proto_rawDesc 527 527 + ) 528 528 + 529 529 + func file_rockbox_search_v1alpha1_like_proto_rawDescGZIP() []byte { 530 530 + file_rockbox_search_v1alpha1_like_proto_rawDescOnce.Do(func() { 531 531 + file_rockbox_search_v1alpha1_like_proto_rawDescData = protoimpl.X.CompressGZIP(file_rockbox_search_v1alpha1_like_proto_rawDescData) 532 532 + }) 533 533 + return file_rockbox_search_v1alpha1_like_proto_rawDescData 534 534 + } 535 535 + 536 536 + var file_rockbox_search_v1alpha1_like_proto_msgTypes = make([]protoimpl.MessageInfo, 4) 537 537 + var file_rockbox_search_v1alpha1_like_proto_goTypes = []interface{}{ 538 538 + (*LikedAlbum)(nil), // 0: rockbox.search.v1alpha1.LikedAlbum 539 539 + (*LikedTrack)(nil), // 1: rockbox.search.v1alpha1.LikedTrack 540 540 + (*LikedAlbumList)(nil), // 2: rockbox.search.v1alpha1.LikedAlbumList 541 541 + (*LikedTrackList)(nil), // 3: rockbox.search.v1alpha1.LikedTrackList 542 542 + } 543 543 + var file_rockbox_search_v1alpha1_like_proto_depIdxs = []int32{ 544 544 + 0, // 0: rockbox.search.v1alpha1.LikedAlbumList.albums:type_name -> rockbox.search.v1alpha1.LikedAlbum 545 545 + 1, // 1: rockbox.search.v1alpha1.LikedTrackList.tracks:type_name -> rockbox.search.v1alpha1.LikedTrack 546 546 + 2, // [2:2] is the sub-list for method output_type 547 547 + 2, // [2:2] is the sub-list for method input_type 548 548 + 2, // [2:2] is the sub-list for extension type_name 549 549 + 2, // [2:2] is the sub-list for extension extendee 550 550 + 0, // [0:2] is the sub-list for field type_name 551 551 + } 552 552 + 553 553 + func init() { file_rockbox_search_v1alpha1_like_proto_init() } 554 554 + func file_rockbox_search_v1alpha1_like_proto_init() { 555 555 + if File_rockbox_search_v1alpha1_like_proto != nil { 556 556 + return 557 557 + } 558 558 + if !protoimpl.UnsafeEnabled { 559 559 + file_rockbox_search_v1alpha1_like_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { 560 560 + switch v := v.(*LikedAlbum); i { 561 561 + case 0: 562 562 + return &v.state 563 563 + case 1: 564 564 + return &v.sizeCache 565 565 + case 2: 566 566 + return &v.unknownFields 567 567 + default: 568 568 + return nil 569 569 + } 570 570 + } 571 571 + file_rockbox_search_v1alpha1_like_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { 572 572 + switch v := v.(*LikedTrack); i { 573 573 + case 0: 574 574 + return &v.state 575 575 + case 1: 576 576 + return &v.sizeCache 577 577 + case 2: 578 578 + return &v.unknownFields 579 579 + default: 580 580 + return nil 581 581 + } 582 582 + } 583 583 + file_rockbox_search_v1alpha1_like_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { 584 584 + switch v := v.(*LikedAlbumList); i { 585 585 + case 0: 586 586 + return &v.state 587 587 + case 1: 588 588 + return &v.sizeCache 589 589 + case 2: 590 590 + return &v.unknownFields 591 591 + default: 592 592 + return nil 593 593 + } 594 594 + } 595 595 + file_rockbox_search_v1alpha1_like_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { 596 596 + switch v := v.(*LikedTrackList); i { 597 597 + case 0: 598 598 + return &v.state 599 599 + case 1: 600 600 + return &v.sizeCache 601 601 + case 2: 602 602 + return &v.unknownFields 603 603 + default: 604 604 + return nil 605 605 + } 606 606 + } 607 607 + } 608 608 + file_rockbox_search_v1alpha1_like_proto_msgTypes[0].OneofWrappers = []interface{}{} 609 609 + file_rockbox_search_v1alpha1_like_proto_msgTypes[1].OneofWrappers = []interface{}{} 610 610 + type x struct{} 611 611 + out := protoimpl.TypeBuilder{ 612 612 + File: protoimpl.DescBuilder{ 613 613 + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), 614 614 + RawDescriptor: file_rockbox_search_v1alpha1_like_proto_rawDesc, 615 615 + NumEnums: 0, 616 616 + NumMessages: 4, 617 617 + NumExtensions: 0, 618 618 + NumServices: 0, 619 619 + }, 620 620 + GoTypes: file_rockbox_search_v1alpha1_like_proto_goTypes, 621 621 + DependencyIndexes: file_rockbox_search_v1alpha1_like_proto_depIdxs, 622 622 + MessageInfos: file_rockbox_search_v1alpha1_like_proto_msgTypes, 623 623 + }.Build() 624 624 + File_rockbox_search_v1alpha1_like_proto = out.File 625 625 + file_rockbox_search_v1alpha1_like_proto_rawDesc = nil 626 626 + file_rockbox_search_v1alpha1_like_proto_goTypes = nil 627 627 + file_rockbox_search_v1alpha1_like_proto_depIdxs = nil 628 628 + }

+431

search/gen/rockbox/search/v1alpha1/track.pb.go

··· 1 1 + // Code generated by protoc-gen-go. DO NOT EDIT. 2 2 + // versions: 3 3 + // protoc-gen-go v1.31.0 4 4 + // protoc (unknown) 5 5 + // source: rockbox/search/v1alpha1/track.proto 6 6 + 7 7 + package v1alpha1 8 8 + 9 9 + import ( 10 10 + protoreflect "google.golang.org/protobuf/reflect/protoreflect" 11 11 + protoimpl "google.golang.org/protobuf/runtime/protoimpl" 12 12 + reflect "reflect" 13 13 + sync "sync" 14 14 + ) 15 15 + 16 16 + const ( 17 17 + // Verify that this generated code is sufficiently up-to-date. 18 18 + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) 19 19 + // Verify that runtime/protoimpl is sufficiently up-to-date. 20 20 + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) 21 21 + ) 22 22 + 23 23 + type Track struct { 24 24 + state protoimpl.MessageState 25 25 + sizeCache protoimpl.SizeCache 26 26 + unknownFields protoimpl.UnknownFields 27 27 + 28 28 + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 29 29 + Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"` 30 30 + Title string `protobuf:"bytes,3,opt,name=title,proto3" json:"title,omitempty"` 31 31 + Artist string `protobuf:"bytes,4,opt,name=artist,proto3" json:"artist,omitempty"` 32 32 + Album string `protobuf:"bytes,5,opt,name=album,proto3" json:"album,omitempty"` 33 33 + AlbumArtist string `protobuf:"bytes,6,opt,name=album_artist,json=albumArtist,proto3" json:"album_artist,omitempty"` 34 34 + Bitrate uint32 `protobuf:"varint,7,opt,name=bitrate,proto3" json:"bitrate,omitempty"` 35 35 + Composer string `protobuf:"bytes,8,opt,name=composer,proto3" json:"composer,omitempty"` 36 36 + DiscNumber uint32 `protobuf:"varint,9,opt,name=disc_number,json=discNumber,proto3" json:"disc_number,omitempty"` 37 37 + Filesize uint32 `protobuf:"varint,10,opt,name=filesize,proto3" json:"filesize,omitempty"` 38 38 + Frequency uint32 `protobuf:"varint,11,opt,name=frequency,proto3" json:"frequency,omitempty"` 39 39 + Length uint32 `protobuf:"varint,12,opt,name=length,proto3" json:"length,omitempty"` 40 40 + TrackNumber uint32 `protobuf:"varint,13,opt,name=track_number,json=trackNumber,proto3" json:"track_number,omitempty"` 41 41 + Year uint32 `protobuf:"varint,14,opt,name=year,proto3" json:"year,omitempty"` 42 42 + YearString string `protobuf:"bytes,15,opt,name=year_string,json=yearString,proto3" json:"year_string,omitempty"` 43 43 + Genre string `protobuf:"bytes,16,opt,name=genre,proto3" json:"genre,omitempty"` 44 44 + Md5 string `protobuf:"bytes,17,opt,name=md5,proto3" json:"md5,omitempty"` 45 45 + AlbumArt *string `protobuf:"bytes,18,opt,name=album_art,json=albumArt,proto3,oneof" json:"album_art,omitempty"` 46 46 + ArtistId *string `protobuf:"bytes,19,opt,name=artist_id,json=artistId,proto3,oneof" json:"artist_id,omitempty"` 47 47 + AlbumId *string `protobuf:"bytes,20,opt,name=album_id,json=albumId,proto3,oneof" json:"album_id,omitempty"` 48 48 + GenreId *string `protobuf:"bytes,21,opt,name=genre_id,json=genreId,proto3,oneof" json:"genre_id,omitempty"` 49 49 + CreatedAt string `protobuf:"bytes,22,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` 50 50 + UpdatedAt string `protobuf:"bytes,23,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"` 51 51 + } 52 52 + 53 53 + func (x *Track) Reset() { 54 54 + *x = Track{} 55 55 + if protoimpl.UnsafeEnabled { 56 56 + mi := &file_rockbox_search_v1alpha1_track_proto_msgTypes[0] 57 57 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 58 58 + ms.StoreMessageInfo(mi) 59 59 + } 60 60 + } 61 61 + 62 62 + func (x *Track) String() string { 63 63 + return protoimpl.X.MessageStringOf(x) 64 64 + } 65 65 + 66 66 + func (*Track) ProtoMessage() {} 67 67 + 68 68 + func (x *Track) ProtoReflect() protoreflect.Message { 69 69 + mi := &file_rockbox_search_v1alpha1_track_proto_msgTypes[0] 70 70 + if protoimpl.UnsafeEnabled && x != nil { 71 71 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 72 72 + if ms.LoadMessageInfo() == nil { 73 73 + ms.StoreMessageInfo(mi) 74 74 + } 75 75 + return ms 76 76 + } 77 77 + return mi.MessageOf(x) 78 78 + } 79 79 + 80 80 + // Deprecated: Use Track.ProtoReflect.Descriptor instead. 81 81 + func (*Track) Descriptor() ([]byte, []int) { 82 82 + return file_rockbox_search_v1alpha1_track_proto_rawDescGZIP(), []int{0} 83 83 + } 84 84 + 85 85 + func (x *Track) GetId() string { 86 86 + if x != nil { 87 87 + return x.Id 88 88 + } 89 89 + return "" 90 90 + } 91 91 + 92 92 + func (x *Track) GetPath() string { 93 93 + if x != nil { 94 94 + return x.Path 95 95 + } 96 96 + return "" 97 97 + } 98 98 + 99 99 + func (x *Track) GetTitle() string { 100 100 + if x != nil { 101 101 + return x.Title 102 102 + } 103 103 + return "" 104 104 + } 105 105 + 106 106 + func (x *Track) GetArtist() string { 107 107 + if x != nil { 108 108 + return x.Artist 109 109 + } 110 110 + return "" 111 111 + } 112 112 + 113 113 + func (x *Track) GetAlbum() string { 114 114 + if x != nil { 115 115 + return x.Album 116 116 + } 117 117 + return "" 118 118 + } 119 119 + 120 120 + func (x *Track) GetAlbumArtist() string { 121 121 + if x != nil { 122 122 + return x.AlbumArtist 123 123 + } 124 124 + return "" 125 125 + } 126 126 + 127 127 + func (x *Track) GetBitrate() uint32 { 128 128 + if x != nil { 129 129 + return x.Bitrate 130 130 + } 131 131 + return 0 132 132 + } 133 133 + 134 134 + func (x *Track) GetComposer() string { 135 135 + if x != nil { 136 136 + return x.Composer 137 137 + } 138 138 + return "" 139 139 + } 140 140 + 141 141 + func (x *Track) GetDiscNumber() uint32 { 142 142 + if x != nil { 143 143 + return x.DiscNumber 144 144 + } 145 145 + return 0 146 146 + } 147 147 + 148 148 + func (x *Track) GetFilesize() uint32 { 149 149 + if x != nil { 150 150 + return x.Filesize 151 151 + } 152 152 + return 0 153 153 + } 154 154 + 155 155 + func (x *Track) GetFrequency() uint32 { 156 156 + if x != nil { 157 157 + return x.Frequency 158 158 + } 159 159 + return 0 160 160 + } 161 161 + 162 162 + func (x *Track) GetLength() uint32 { 163 163 + if x != nil { 164 164 + return x.Length 165 165 + } 166 166 + return 0 167 167 + } 168 168 + 169 169 + func (x *Track) GetTrackNumber() uint32 { 170 170 + if x != nil { 171 171 + return x.TrackNumber 172 172 + } 173 173 + return 0 174 174 + } 175 175 + 176 176 + func (x *Track) GetYear() uint32 { 177 177 + if x != nil { 178 178 + return x.Year 179 179 + } 180 180 + return 0 181 181 + } 182 182 + 183 183 + func (x *Track) GetYearString() string { 184 184 + if x != nil { 185 185 + return x.YearString 186 186 + } 187 187 + return "" 188 188 + } 189 189 + 190 190 + func (x *Track) GetGenre() string { 191 191 + if x != nil { 192 192 + return x.Genre 193 193 + } 194 194 + return "" 195 195 + } 196 196 + 197 197 + func (x *Track) GetMd5() string { 198 198 + if x != nil { 199 199 + return x.Md5 200 200 + } 201 201 + return "" 202 202 + } 203 203 + 204 204 + func (x *Track) GetAlbumArt() string { 205 205 + if x != nil && x.AlbumArt != nil { 206 206 + return *x.AlbumArt 207 207 + } 208 208 + return "" 209 209 + } 210 210 + 211 211 + func (x *Track) GetArtistId() string { 212 212 + if x != nil && x.ArtistId != nil { 213 213 + return *x.ArtistId 214 214 + } 215 215 + return "" 216 216 + } 217 217 + 218 218 + func (x *Track) GetAlbumId() string { 219 219 + if x != nil && x.AlbumId != nil { 220 220 + return *x.AlbumId 221 221 + } 222 222 + return "" 223 223 + } 224 224 + 225 225 + func (x *Track) GetGenreId() string { 226 226 + if x != nil && x.GenreId != nil { 227 227 + return *x.GenreId 228 228 + } 229 229 + return "" 230 230 + } 231 231 + 232 232 + func (x *Track) GetCreatedAt() string { 233 233 + if x != nil { 234 234 + return x.CreatedAt 235 235 + } 236 236 + return "" 237 237 + } 238 238 + 239 239 + func (x *Track) GetUpdatedAt() string { 240 240 + if x != nil { 241 241 + return x.UpdatedAt 242 242 + } 243 243 + return "" 244 244 + } 245 245 + 246 246 + type TrackList struct { 247 247 + state protoimpl.MessageState 248 248 + sizeCache protoimpl.SizeCache 249 249 + unknownFields protoimpl.UnknownFields 250 250 + 251 251 + Tracks []*Track `protobuf:"bytes,1,rep,name=tracks,proto3" json:"tracks,omitempty"` 252 252 + } 253 253 + 254 254 + func (x *TrackList) Reset() { 255 255 + *x = TrackList{} 256 256 + if protoimpl.UnsafeEnabled { 257 257 + mi := &file_rockbox_search_v1alpha1_track_proto_msgTypes[1] 258 258 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 259 259 + ms.StoreMessageInfo(mi) 260 260 + } 261 261 + } 262 262 + 263 263 + func (x *TrackList) String() string { 264 264 + return protoimpl.X.MessageStringOf(x) 265 265 + } 266 266 + 267 267 + func (*TrackList) ProtoMessage() {} 268 268 + 269 269 + func (x *TrackList) ProtoReflect() protoreflect.Message { 270 270 + mi := &file_rockbox_search_v1alpha1_track_proto_msgTypes[1] 271 271 + if protoimpl.UnsafeEnabled && x != nil { 272 272 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 273 273 + if ms.LoadMessageInfo() == nil { 274 274 + ms.StoreMessageInfo(mi) 275 275 + } 276 276 + return ms 277 277 + } 278 278 + return mi.MessageOf(x) 279 279 + } 280 280 + 281 281 + // Deprecated: Use TrackList.ProtoReflect.Descriptor instead. 282 282 + func (*TrackList) Descriptor() ([]byte, []int) { 283 283 + return file_rockbox_search_v1alpha1_track_proto_rawDescGZIP(), []int{1} 284 284 + } 285 285 + 286 286 + func (x *TrackList) GetTracks() []*Track { 287 287 + if x != nil { 288 288 + return x.Tracks 289 289 + } 290 290 + return nil 291 291 + } 292 292 + 293 293 + var File_rockbox_search_v1alpha1_track_proto protoreflect.FileDescriptor 294 294 + 295 295 + var file_rockbox_search_v1alpha1_track_proto_rawDesc = []byte{ 296 296 + 0x0a, 0x23, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2f, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 297 297 + 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x2e, 298 298 + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x17, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2e, 0x73, 299 299 + 0x65, 0x61, 0x72, 0x63, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x22, 0xb3, 300 300 + 0x05, 0x0a, 0x05, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 301 301 + 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 302 302 + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x14, 0x0a, 0x05, 303 303 + 0x74, 0x69, 0x74, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x69, 0x74, 304 304 + 0x6c, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x18, 0x04, 0x20, 0x01, 305 305 + 0x28, 0x09, 0x52, 0x06, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x6c, 306 306 + 0x62, 0x75, 0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x6c, 0x62, 0x75, 0x6d, 307 307 + 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x5f, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 308 308 + 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x41, 0x72, 0x74, 309 309 + 0x69, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x62, 0x69, 0x74, 0x72, 0x61, 0x74, 0x65, 0x18, 0x07, 310 310 + 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x62, 0x69, 0x74, 0x72, 0x61, 0x74, 0x65, 0x12, 0x1a, 0x0a, 311 311 + 0x08, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 312 312 + 0x08, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x64, 0x69, 0x73, 313 313 + 0x63, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 314 314 + 0x64, 0x69, 0x73, 0x63, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 315 315 + 0x6c, 0x65, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x66, 0x69, 316 316 + 0x6c, 0x65, 0x73, 0x69, 0x7a, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x72, 0x65, 0x71, 0x75, 0x65, 317 317 + 0x6e, 0x63, 0x79, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x66, 0x72, 0x65, 0x71, 0x75, 318 318 + 0x65, 0x6e, 0x63, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x18, 0x0c, 319 319 + 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x12, 0x21, 0x0a, 0x0c, 320 320 + 0x74, 0x72, 0x61, 0x63, 0x6b, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x0d, 0x20, 0x01, 321 321 + 0x28, 0x0d, 0x52, 0x0b, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 322 322 + 0x12, 0x0a, 0x04, 0x79, 0x65, 0x61, 0x72, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x79, 323 323 + 0x65, 0x61, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x79, 0x65, 0x61, 0x72, 0x5f, 0x73, 0x74, 0x72, 0x69, 324 324 + 0x6e, 0x67, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x79, 0x65, 0x61, 0x72, 0x53, 0x74, 325 325 + 0x72, 0x69, 0x6e, 0x67, 0x12, 0x14, 0x0a, 0x05, 0x67, 0x65, 0x6e, 0x72, 0x65, 0x18, 0x10, 0x20, 326 326 + 0x01, 0x28, 0x09, 0x52, 0x05, 0x67, 0x65, 0x6e, 0x72, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6d, 0x64, 327 327 + 0x35, 0x18, 0x11, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6d, 0x64, 0x35, 0x12, 0x20, 0x0a, 0x09, 328 328 + 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x5f, 0x61, 0x72, 0x74, 0x18, 0x12, 0x20, 0x01, 0x28, 0x09, 0x48, 329 329 + 0x00, 0x52, 0x08, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x41, 0x72, 0x74, 0x88, 0x01, 0x01, 0x12, 0x20, 330 330 + 0x0a, 0x09, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x13, 0x20, 0x01, 0x28, 331 331 + 0x09, 0x48, 0x01, 0x52, 0x08, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x49, 0x64, 0x88, 0x01, 0x01, 332 332 + 0x12, 0x1e, 0x0a, 0x08, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x14, 0x20, 0x01, 333 333 + 0x28, 0x09, 0x48, 0x02, 0x52, 0x07, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x49, 0x64, 0x88, 0x01, 0x01, 334 334 + 0x12, 0x1e, 0x0a, 0x08, 0x67, 0x65, 0x6e, 0x72, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x15, 0x20, 0x01, 335 335 + 0x28, 0x09, 0x48, 0x03, 0x52, 0x07, 0x67, 0x65, 0x6e, 0x72, 0x65, 0x49, 0x64, 0x88, 0x01, 0x01, 336 336 + 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x16, 337 337 + 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 338 338 + 0x1d, 0x0a, 0x0a, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x17, 0x20, 339 339 + 0x01, 0x28, 0x09, 0x52, 0x09, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x42, 0x0c, 340 340 + 0x0a, 0x0a, 0x5f, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x5f, 0x61, 0x72, 0x74, 0x42, 0x0c, 0x0a, 0x0a, 341 341 + 0x5f, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x61, 342 342 + 0x6c, 0x62, 0x75, 0x6d, 0x5f, 0x69, 0x64, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x67, 0x65, 0x6e, 0x72, 343 343 + 0x65, 0x5f, 0x69, 0x64, 0x22, 0x43, 0x0a, 0x09, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x4c, 0x69, 0x73, 344 344 + 0x74, 0x12, 0x36, 0x0a, 0x06, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 345 345 + 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2e, 0x73, 0x65, 0x61, 0x72, 346 346 + 0x63, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x54, 0x72, 0x61, 0x63, 347 347 + 0x6b, 0x52, 0x06, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x73, 0x42, 0x3e, 0x5a, 0x3c, 0x67, 0x69, 0x74, 348 348 + 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x74, 0x73, 0x69, 0x72, 0x79, 0x73, 0x6e, 0x64, 349 349 + 0x72, 0x2f, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2d, 0x7a, 0x69, 0x67, 0x2f, 0x67, 0x65, 350 350 + 0x6e, 0x2f, 0x72, 0x6f, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x2f, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 351 351 + 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 352 352 + 0x33, 353 353 + } 354 354 + 355 355 + var ( 356 356 + file_rockbox_search_v1alpha1_track_proto_rawDescOnce sync.Once 357 357 + file_rockbox_search_v1alpha1_track_proto_rawDescData = file_rockbox_search_v1alpha1_track_proto_rawDesc 358 358 + ) 359 359 + 360 360 + func file_rockbox_search_v1alpha1_track_proto_rawDescGZIP() []byte { 361 361 + file_rockbox_search_v1alpha1_track_proto_rawDescOnce.Do(func() { 362 362 + file_rockbox_search_v1alpha1_track_proto_rawDescData = protoimpl.X.CompressGZIP(file_rockbox_search_v1alpha1_track_proto_rawDescData) 363 363 + }) 364 364 + return file_rockbox_search_v1alpha1_track_proto_rawDescData 365 365 + } 366 366 + 367 367 + var file_rockbox_search_v1alpha1_track_proto_msgTypes = make([]protoimpl.MessageInfo, 2) 368 368 + var file_rockbox_search_v1alpha1_track_proto_goTypes = []interface{}{ 369 369 + (*Track)(nil), // 0: rockbox.search.v1alpha1.Track 370 370 + (*TrackList)(nil), // 1: rockbox.search.v1alpha1.TrackList 371 371 + } 372 372 + var file_rockbox_search_v1alpha1_track_proto_depIdxs = []int32{ 373 373 + 0, // 0: rockbox.search.v1alpha1.TrackList.tracks:type_name -> rockbox.search.v1alpha1.Track 374 374 + 1, // [1:1] is the sub-list for method output_type 375 375 + 1, // [1:1] is the sub-list for method input_type 376 376 + 1, // [1:1] is the sub-list for extension type_name 377 377 + 1, // [1:1] is the sub-list for extension extendee 378 378 + 0, // [0:1] is the sub-list for field type_name 379 379 + } 380 380 + 381 381 + func init() { file_rockbox_search_v1alpha1_track_proto_init() } 382 382 + func file_rockbox_search_v1alpha1_track_proto_init() { 383 383 + if File_rockbox_search_v1alpha1_track_proto != nil { 384 384 + return 385 385 + } 386 386 + if !protoimpl.UnsafeEnabled { 387 387 + file_rockbox_search_v1alpha1_track_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { 388 388 + switch v := v.(*Track); i { 389 389 + case 0: 390 390 + return &v.state 391 391 + case 1: 392 392 + return &v.sizeCache 393 393 + case 2: 394 394 + return &v.unknownFields 395 395 + default: 396 396 + return nil 397 397 + } 398 398 + } 399 399 + file_rockbox_search_v1alpha1_track_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { 400 400 + switch v := v.(*TrackList); i { 401 401 + case 0: 402 402 + return &v.state 403 403 + case 1: 404 404 + return &v.sizeCache 405 405 + case 2: 406 406 + return &v.unknownFields 407 407 + default: 408 408 + return nil 409 409 + } 410 410 + } 411 411 + } 412 412 + file_rockbox_search_v1alpha1_track_proto_msgTypes[0].OneofWrappers = []interface{}{} 413 413 + type x struct{} 414 414 + out := protoimpl.TypeBuilder{ 415 415 + File: protoimpl.DescBuilder{ 416 416 + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), 417 417 + RawDescriptor: file_rockbox_search_v1alpha1_track_proto_rawDesc, 418 418 + NumEnums: 0, 419 419 + NumMessages: 2, 420 420 + NumExtensions: 0, 421 421 + NumServices: 0, 422 422 + }, 423 423 + GoTypes: file_rockbox_search_v1alpha1_track_proto_goTypes, 424 424 + DependencyIndexes: file_rockbox_search_v1alpha1_track_proto_depIdxs, 425 425 + MessageInfos: file_rockbox_search_v1alpha1_track_proto_msgTypes, 426 426 + }.Build() 427 427 + File_rockbox_search_v1alpha1_track_proto = out.File 428 428 + file_rockbox_search_v1alpha1_track_proto_rawDesc = nil 429 429 + file_rockbox_search_v1alpha1_track_proto_goTypes = nil 430 430 + file_rockbox_search_v1alpha1_track_proto_depIdxs = nil 431 431 + }

+40

search/go.mod

··· 1 1 + module github.com/tsirysndr/rockbox-zig/search 2 2 + 3 3 + go 1.22.2 4 4 + 5 5 + require ( 6 6 + github.com/blevesearch/bleve v1.0.14 7 7 + github.com/blevesearch/bleve/v2 v2.4.2 8 8 + github.com/mitchellh/go-homedir v1.1.0 9 9 + google.golang.org/protobuf v1.35.1 10 10 + ) 11 11 + 12 12 + require ( 13 13 + github.com/RoaringBitmap/roaring v1.9.3 // indirect 14 14 + github.com/bits-and-blooms/bitset v1.12.0 // indirect 15 15 + github.com/blevesearch/bleve_index_api v1.1.10 // indirect 16 16 + github.com/blevesearch/geo v0.1.20 // indirect 17 17 + github.com/blevesearch/go-faiss v1.0.20 // indirect 18 18 + github.com/blevesearch/go-porterstemmer v1.0.3 // indirect 19 19 + github.com/blevesearch/gtreap v0.1.1 // indirect 20 20 + github.com/blevesearch/mmap-go v1.0.4 // indirect 21 21 + github.com/blevesearch/scorch_segment_api/v2 v2.2.15 // indirect 22 22 + github.com/blevesearch/segment v0.9.1 // indirect 23 23 + github.com/blevesearch/snowballstem v0.9.0 // indirect 24 24 + github.com/blevesearch/upsidedown_store_api v1.0.2 // indirect 25 25 + github.com/blevesearch/vellum v1.0.10 // indirect 26 26 + github.com/blevesearch/zapx/v11 v11.3.10 // indirect 27 27 + github.com/blevesearch/zapx/v12 v12.3.10 // indirect 28 28 + github.com/blevesearch/zapx/v13 v13.3.10 // indirect 29 29 + github.com/blevesearch/zapx/v14 v14.3.10 // indirect 30 30 + github.com/blevesearch/zapx/v15 v15.3.13 // indirect 31 31 + github.com/blevesearch/zapx/v16 v16.1.5 // indirect 32 32 + github.com/golang/geo v0.0.0-20210211234256-740aa86cb551 // indirect 33 33 + github.com/golang/protobuf v1.5.0 // indirect 34 34 + github.com/golang/snappy v0.0.1 // indirect 35 35 + github.com/json-iterator/go v0.0.0-20171115153421-f7279a603ede // indirect 36 36 + github.com/mitchellh/mapstructure v1.5.0 // indirect 37 37 + github.com/mschoch/smat v0.2.0 // indirect 38 38 + go.etcd.io/bbolt v1.3.7 // indirect 39 39 + golang.org/x/sys v0.13.0 // indirect 40 40 + )

+154

search/go.sum

··· 1 1 + github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= 2 2 + github.com/RoaringBitmap/roaring v0.4.23/go.mod h1:D0gp8kJQgE1A4LQ5wFLggQEyvDi06Mq5mKs52e1TwOo= 3 3 + github.com/RoaringBitmap/roaring v1.9.3 h1:t4EbC5qQwnisr5PrP9nt0IRhRTb9gMUgQF4t4S2OByM= 4 4 + github.com/RoaringBitmap/roaring v1.9.3/go.mod h1:6AXUsoIEzDTFFQCe1RbGA6uFONMhvejWj5rqITANK90= 5 5 + github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8= 6 6 + github.com/bits-and-blooms/bitset v1.12.0 h1:U/q1fAF7xXRhFCrhROzIfffYnu+dlS38vCZtmFVPHmA= 7 7 + github.com/bits-and-blooms/bitset v1.12.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= 8 8 + github.com/blevesearch/bleve v1.0.14 h1:Q8r+fHTt35jtGXJUM0ULwM3Tzg+MRfyai4ZkWDy2xO4= 9 9 + github.com/blevesearch/bleve v1.0.14/go.mod h1:e/LJTr+E7EaoVdkQZTfoz7dt4KoDNvDbLb8MSKuNTLQ= 10 10 + github.com/blevesearch/bleve/v2 v2.4.2 h1:NooYP1mb3c0StkiY9/xviiq2LGSaE8BQBCc/pirMx0U= 11 11 + github.com/blevesearch/bleve/v2 v2.4.2/go.mod h1:ATNKj7Yl2oJv/lGuF4kx39bST2dveX6w0th2FFYLkc8= 12 12 + github.com/blevesearch/bleve_index_api v1.1.10 h1:PDLFhVjrjQWr6jCuU7TwlmByQVCSEURADHdCqVS9+g0= 13 13 + github.com/blevesearch/bleve_index_api v1.1.10/go.mod h1:PbcwjIcRmjhGbkS/lJCpfgVSMROV6TRubGGAODaK1W8= 14 14 + github.com/blevesearch/blevex v1.0.0/go.mod h1:2rNVqoG2BZI8t1/P1awgTKnGlx5MP9ZbtEciQaNhswc= 15 15 + github.com/blevesearch/cld2 v0.0.0-20200327141045-8b5f551d37f5/go.mod h1:PN0QNTLs9+j1bKy3d/GB/59wsNBFC4sWLWG3k69lWbc= 16 16 + github.com/blevesearch/geo v0.1.20 h1:paaSpu2Ewh/tn5DKn/FB5SzvH0EWupxHEIwbCk/QPqM= 17 17 + github.com/blevesearch/geo v0.1.20/go.mod h1:DVG2QjwHNMFmjo+ZgzrIq2sfCh6rIHzy9d9d0B59I6w= 18 18 + github.com/blevesearch/go-faiss v1.0.20 h1:AIkdTQFWuZ5LQmKQSebgMR4RynGNw8ZseJXaan5kvtI= 19 19 + github.com/blevesearch/go-faiss v1.0.20/go.mod h1:jrxHrbl42X/RnDPI+wBoZU8joxxuRwedrxqswQ3xfU8= 20 20 + github.com/blevesearch/go-porterstemmer v1.0.3 h1:GtmsqID0aZdCSNiY8SkuPJ12pD4jI+DdXTAn4YRcHCo= 21 21 + github.com/blevesearch/go-porterstemmer v1.0.3/go.mod h1:angGc5Ht+k2xhJdZi511LtmxuEf0OVpvUUNrwmM1P7M= 22 22 + github.com/blevesearch/gtreap v0.1.1 h1:2JWigFrzDMR+42WGIN/V2p0cUvn4UP3C4Q5nmaZGW8Y= 23 23 + github.com/blevesearch/gtreap v0.1.1/go.mod h1:QaQyDRAT51sotthUWAH4Sj08awFSSWzgYICSZ3w0tYk= 24 24 + github.com/blevesearch/mmap-go v1.0.2/go.mod h1:ol2qBqYaOUsGdm7aRMRrYGgPvnwLe6Y+7LMvAB5IbSA= 25 25 + github.com/blevesearch/mmap-go v1.0.4 h1:OVhDhT5B/M1HNPpYPBKIEJaD0F3Si+CrEKULGCDPWmc= 26 26 + github.com/blevesearch/mmap-go v1.0.4/go.mod h1:EWmEAOmdAS9z/pi/+Toxu99DnsbhG1TIxUoRmJw/pSs= 27 27 + github.com/blevesearch/scorch_segment_api/v2 v2.2.15 h1:prV17iU/o+A8FiZi9MXmqbagd8I0bCqM7OKUYPbnb5Y= 28 28 + github.com/blevesearch/scorch_segment_api/v2 v2.2.15/go.mod h1:db0cmP03bPNadXrCDuVkKLV6ywFSiRgPFT1YVrestBc= 29 29 + github.com/blevesearch/segment v0.9.0/go.mod h1:9PfHYUdQCgHktBgvtUOF4x+pc4/l8rdH0u5spnW85UQ= 30 30 + github.com/blevesearch/segment v0.9.1 h1:+dThDy+Lvgj5JMxhmOVlgFfkUtZV2kw49xax4+jTfSU= 31 31 + github.com/blevesearch/segment v0.9.1/go.mod h1:zN21iLm7+GnBHWTao9I+Au/7MBiL8pPFtJBJTsk6kQw= 32 32 + github.com/blevesearch/snowballstem v0.9.0 h1:lMQ189YspGP6sXvZQ4WZ+MLawfV8wOmPoD/iWeNXm8s= 33 33 + github.com/blevesearch/snowballstem v0.9.0/go.mod h1:PivSj3JMc8WuaFkTSRDW2SlrulNWPl4ABg1tC/hlgLs= 34 34 + github.com/blevesearch/upsidedown_store_api v1.0.2 h1:U53Q6YoWEARVLd1OYNc9kvhBMGZzVrdmaozG2MfoB+A= 35 35 + github.com/blevesearch/upsidedown_store_api v1.0.2/go.mod h1:M01mh3Gpfy56Ps/UXHjEO/knbqyQ1Oamg8If49gRwrQ= 36 36 + github.com/blevesearch/vellum v1.0.10 h1:HGPJDT2bTva12hrHepVT3rOyIKFFF4t7Gf6yMxyMIPI= 37 37 + github.com/blevesearch/vellum v1.0.10/go.mod h1:ul1oT0FhSMDIExNjIxHqJoGpVrBpKCdgDQNxfqgJt7k= 38 38 + github.com/blevesearch/zap/v11 v11.0.14/go.mod h1:MUEZh6VHGXv1PKx3WnCbdP404LGG2IZVa/L66pyFwnY= 39 39 + github.com/blevesearch/zap/v12 v12.0.14/go.mod h1:rOnuZOiMKPQj18AEKEHJxuI14236tTQ1ZJz4PAnWlUg= 40 40 + github.com/blevesearch/zap/v13 v13.0.6/go.mod h1:L89gsjdRKGyGrRN6nCpIScCvvkyxvmeDCwZRcjjPCrw= 41 41 + github.com/blevesearch/zap/v14 v14.0.5/go.mod h1:bWe8S7tRrSBTIaZ6cLRbgNH4TUDaC9LZSpRGs85AsGY= 42 42 + github.com/blevesearch/zap/v15 v15.0.3/go.mod h1:iuwQrImsh1WjWJ0Ue2kBqY83a0rFtJTqfa9fp1rbVVU= 43 43 + github.com/blevesearch/zapx/v11 v11.3.10 h1:hvjgj9tZ9DeIqBCxKhi70TtSZYMdcFn7gDb71Xo/fvk= 44 44 + github.com/blevesearch/zapx/v11 v11.3.10/go.mod h1:0+gW+FaE48fNxoVtMY5ugtNHHof/PxCqh7CnhYdnMzQ= 45 45 + github.com/blevesearch/zapx/v12 v12.3.10 h1:yHfj3vXLSYmmsBleJFROXuO08mS3L1qDCdDK81jDl8s= 46 46 + github.com/blevesearch/zapx/v12 v12.3.10/go.mod h1:0yeZg6JhaGxITlsS5co73aqPtM04+ycnI6D1v0mhbCs= 47 47 + github.com/blevesearch/zapx/v13 v13.3.10 h1:0KY9tuxg06rXxOZHg3DwPJBjniSlqEgVpxIqMGahDE8= 48 48 + github.com/blevesearch/zapx/v13 v13.3.10/go.mod h1:w2wjSDQ/WBVeEIvP0fvMJZAzDwqwIEzVPnCPrz93yAk= 49 49 + github.com/blevesearch/zapx/v14 v14.3.10 h1:SG6xlsL+W6YjhX5N3aEiL/2tcWh3DO75Bnz77pSwwKU= 50 50 + github.com/blevesearch/zapx/v14 v14.3.10/go.mod h1:qqyuR0u230jN1yMmE4FIAuCxmahRQEOehF78m6oTgns= 51 51 + github.com/blevesearch/zapx/v15 v15.3.13 h1:6EkfaZiPlAxqXz0neniq35my6S48QI94W/wyhnpDHHQ= 52 52 + github.com/blevesearch/zapx/v15 v15.3.13/go.mod h1:Turk/TNRKj9es7ZpKK95PS7f6D44Y7fAFy8F4LXQtGg= 53 53 + github.com/blevesearch/zapx/v16 v16.1.5 h1:b0sMcarqNFxuXvjoXsF8WtwVahnxyhEvBSRJi/AUHjU= 54 54 + github.com/blevesearch/zapx/v16 v16.1.5/go.mod h1:J4mSF39w1QELc11EWRSBFkPeZuO7r/NPKkHzDCoiaI8= 55 55 + github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= 56 56 + github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk= 57 57 + github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= 58 58 + github.com/couchbase/ghistogram v0.1.0/go.mod h1:s1Jhy76zqfEecpNWJfWUiKZookAFaiGOEoyzgHt9i7k= 59 59 + github.com/couchbase/moss v0.1.0/go.mod h1:9MaHIaRuy9pvLPUJxB8sh8OrLfyDczECVL37grCIubs= 60 60 + github.com/couchbase/vellum v1.0.2/go.mod h1:FcwrEivFpNi24R3jLOs3n+fs5RnuQnQqCLBJ1uAg1W4= 61 61 + github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE= 62 62 + github.com/cznic/b v0.0.0-20181122101859-a26611c4d92d/go.mod h1:URriBxXwVq5ijiJ12C7iIZqlA69nTlI+LgI6/pwftG8= 63 63 + github.com/cznic/mathutil v0.0.0-20181122101859-297441e03548/go.mod h1:e6NPNENfs9mPDVNRekM7lKScauxd5kXTr1Mfyig6TDM= 64 64 + github.com/cznic/strutil v0.0.0-20181122101858-275e90344537/go.mod h1:AHHPPPXTw0h6pVabbcbyGRK1DckRn7r/STdZEeIDzZc= 65 65 + github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 66 66 + github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 67 67 + github.com/facebookgo/ensure v0.0.0-20200202191622-63f1cf65ac4c/go.mod h1:Yg+htXGokKKdzcwhuNDwVvN+uBxDGXJ7G/VN1d8fa64= 68 68 + github.com/facebookgo/stack v0.0.0-20160209184415-751773369052/go.mod h1:UbMTZqLaRiH3MsBH8va0n7s1pQYcu3uTb8G4tygF4Zg= 69 69 + github.com/facebookgo/subset v0.0.0-20200203212716-c811ad88dec4/go.mod h1:5tD+neXqOorC30/tWg0LCSkrqj/AR6gu8yY8/fpw1q0= 70 70 + github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= 71 71 + github.com/glycerine/go-unsnap-stream v0.0.0-20181221182339-f9677308dec2/go.mod h1:/20jfyN9Y5QPEAprSgKAUr+glWDY39ZiUEAYOEv5dsE= 72 72 + github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24= 73 73 + github.com/golang/geo v0.0.0-20210211234256-740aa86cb551 h1:gtexQ/VGyN+VVFRXSFiguSNcXmS6rkKT+X7FdIrTtfo= 74 74 + github.com/golang/geo v0.0.0-20210211234256-740aa86cb551/go.mod h1:QZ0nwyI2jOfgRAoBvP+ab5aRr7c9x7lhGEJrKvBwjWI= 75 75 + github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= 76 76 + github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs= 77 77 + github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= 78 78 + github.com/golang/protobuf v1.5.0 h1:LUVKkCeviFUMKqHa4tXIIij/lbhnMbP7Fn5wKdKkRh4= 79 79 + github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= 80 80 + github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= 81 81 + github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4= 82 82 + github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= 83 83 + github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= 84 84 + github.com/gopherjs/gopherjs v0.0.0-20190910122728-9d188e94fb99/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= 85 85 + github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= 86 86 + github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= 87 87 + github.com/ikawaha/kagome.ipadic v1.1.2/go.mod h1:DPSBbU0czaJhAb/5uKQZHMc9MTVRpDugJfX+HddPHHg= 88 88 + github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= 89 89 + github.com/jmhodges/levigo v1.0.0/go.mod h1:Q6Qx+uH3RAqyK4rFQroq9RL7mdkABMcfhEI+nNuzMJQ= 90 90 + github.com/json-iterator/go v0.0.0-20171115153421-f7279a603ede h1:YrgBGwxMRK0Vq0WSCWFaZUnTsrA/PZE/xs1QZh+/edg= 91 91 + github.com/json-iterator/go v0.0.0-20171115153421-f7279a603ede/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= 92 92 + github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= 93 93 + github.com/kljensen/snowball v0.6.0/go.mod h1:27N7E8fVU5H68RlUmnWwZCfxgt4POBJfENGMvNRhldw= 94 94 + github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= 95 95 + github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y= 96 96 + github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= 97 97 + github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= 98 98 + github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= 99 99 + github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= 100 100 + github.com/mschoch/smat v0.0.0-20160514031455-90eadee771ae/go.mod h1:qAyveg+e4CE+eKJXWVjKXM4ck2QobLqTDytGJbLLhJg= 101 101 + github.com/mschoch/smat v0.2.0 h1:8imxQsjDm8yFEAVBe7azKmKSgzSkZXDuKkSq9374khM= 102 102 + github.com/mschoch/smat v0.2.0/go.mod h1:kc9mz7DoBKqDyiRL7VZN8KvXQMWeTaVnttLRXOlotKw= 103 103 + github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= 104 104 + github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= 105 105 + github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= 106 106 + github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= 107 107 + github.com/philhofer/fwd v1.0.0/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU= 108 108 + github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= 109 109 + github.com/rcrowley/go-metrics v0.0.0-20190826022208-cac0b30c2563/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= 110 110 + github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= 111 111 + github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g= 112 112 + github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ= 113 113 + github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= 114 114 + github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU= 115 115 + github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo= 116 116 + github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= 117 117 + github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s= 118 118 + github.com/steveyen/gtreap v0.1.0/go.mod h1:kl/5J7XbrOmlIbYIXdRHDDE5QxHqpk0cmkT7Z4dM9/Y= 119 119 + github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= 120 120 + github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= 121 121 + github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= 122 122 + github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= 123 123 + github.com/syndtr/goleveldb v1.0.0/go.mod h1:ZVVdQEZoIme9iO1Ch2Jdy24qqXrMMOU6lpPAyBWyWuQ= 124 124 + github.com/tebeka/snowball v0.4.2/go.mod h1:4IfL14h1lvwZcp1sfXuuc7/7yCsvVffTWxWxCLfFpYg= 125 125 + github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c/go.mod h1:ahpPrc7HpcfEWDQRZEmnXMzHY03mLDYMCxeDzy46i+8= 126 126 + github.com/tinylib/msgp v1.1.0/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE= 127 127 + github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0= 128 128 + github.com/willf/bitset v1.1.10/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4= 129 129 + github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q= 130 130 + go.etcd.io/bbolt v1.3.5/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ= 131 131 + go.etcd.io/bbolt v1.3.7 h1:j+zJOnnEjF/kyHlDDgGnVL/AIqIJPq8UoB2GSNfkUfQ= 132 132 + go.etcd.io/bbolt v1.3.7/go.mod h1:N9Mkw9X8x5fupy0IKsmuqVtoGDyxsaDlbk4Rd05IAQw= 133 133 + golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= 134 134 + golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= 135 135 + golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= 136 136 + golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= 137 137 + golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= 138 138 + golang.org/x/sys v0.0.0-20181221143128-b4a75ba826a6/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= 139 139 + golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 140 140 + golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 141 141 + golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 142 142 + golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE= 143 143 + golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 144 144 + golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= 145 145 + golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= 146 146 + google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= 147 147 + google.golang.org/protobuf v1.35.1 h1:m3LfL6/Ca+fqnjnlqQXNpFPABW1UD7mjh8KO2mKFytA= 148 148 + google.golang.org/protobuf v1.35.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= 149 149 + gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= 150 150 + gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= 151 151 + gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= 152 152 + gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= 153 153 + gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= 154 154 + gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

+100

search/librockboxsearch.h

··· 1 1 + /* Code generated by cmd/cgo; DO NOT EDIT. */ 2 2 + 3 3 + /* package github.com/tsirysndr/rockbox-zig/search */ 4 4 + 5 5 + 6 6 + #line 1 "cgo-builtin-export-prolog" 7 7 + 8 8 + #include <stddef.h> 9 9 + 10 10 + #ifndef GO_CGO_EXPORT_PROLOGUE_H 11 11 + #define GO_CGO_EXPORT_PROLOGUE_H 12 12 + 13 13 + #ifndef GO_CGO_GOSTRING_TYPEDEF 14 14 + typedef struct { const char *p; ptrdiff_t n; } _GoString_; 15 15 + #endif 16 16 + 17 17 + #endif 18 18 + 19 19 + /* Start of preamble from import "C" comments. */ 20 20 + 21 21 + 22 22 + 23 23 + 24 24 + /* End of preamble from import "C" comments. */ 25 25 + 26 26 + 27 27 + /* Start of boilerplate cgo prologue. */ 28 28 + #line 1 "cgo-gcc-export-header-prolog" 29 29 + 30 30 + #ifndef GO_CGO_PROLOGUE_H 31 31 + #define GO_CGO_PROLOGUE_H 32 32 + 33 33 + typedef signed char GoInt8; 34 34 + typedef unsigned char GoUint8; 35 35 + typedef short GoInt16; 36 36 + typedef unsigned short GoUint16; 37 37 + typedef int GoInt32; 38 38 + typedef unsigned int GoUint32; 39 39 + typedef long long GoInt64; 40 40 + typedef unsigned long long GoUint64; 41 41 + typedef GoInt64 GoInt; 42 42 + typedef GoUint64 GoUint; 43 43 + typedef size_t GoUintptr; 44 44 + typedef float GoFloat32; 45 45 + typedef double GoFloat64; 46 46 + #ifdef _MSC_VER 47 47 + #include <complex.h> 48 48 + typedef _Fcomplex GoComplex64; 49 49 + typedef _Dcomplex GoComplex128; 50 50 + #else 51 51 + typedef float _Complex GoComplex64; 52 52 + typedef double _Complex GoComplex128; 53 53 + #endif 54 54 + 55 55 + /* 56 56 + static assertion to make sure the file is being used on architecture 57 57 + at least with matching size of GoInt. 58 58 + */ 59 59 + typedef char _check_for_64_bit_pointer_matching_GoInt[sizeof(void*)==64/8 ? 1:-1]; 60 60 + 61 61 + #ifndef GO_CGO_GOSTRING_TYPEDEF 62 62 + typedef _GoString_ GoString; 63 63 + #endif 64 64 + typedef void *GoMap; 65 65 + typedef void *GoChan; 66 66 + typedef struct { void *t; void *v; } GoInterface; 67 67 + typedef struct { void *data; GoInt len; GoInt cap; } GoSlice; 68 68 + 69 69 + #endif 70 70 + 71 71 + /* End of boilerplate cgo prologue. */ 72 72 + 73 73 + #ifdef __cplusplus 74 74 + extern "C" { 75 75 + #endif 76 76 + 77 77 + extern void IndexAlbum(char* data, int size); 78 78 + extern void IndexArtist(char* data, int size); 79 79 + extern void IndexFile(char* data, int size); 80 80 + extern void IndexPlaylist(); 81 81 + extern void IndexLikedTrack(char* data, int size); 82 82 + extern void IndexLikedAlbum(char* data, int size); 83 83 + extern void IndexTrack(char* data, int size); 84 84 + extern void IndexAlbums(char* data, int size); 85 85 + extern void IndexArtists(char* data, int size); 86 86 + extern void IndexFiles(char* data, int size); 87 87 + extern void IndexPlaylists(); 88 88 + extern void IndexLikedTracks(char* data, int size); 89 89 + extern void IndexLikedAlbums(char* data, int size); 90 90 + extern void IndexTracks(char* data, int size); 91 91 + extern char* SearchAlbum(char* term); 92 92 + extern char* SearchArtist(char* term); 93 93 + extern char* SearchFile(char* term); 94 94 + extern char* SearchTrack(char* term); 95 95 + extern char* SearchLikedTrack(char* term); 96 96 + extern char* SearchLikedAlbum(char* term); 97 97 + 98 98 + #ifdef __cplusplus 99 99 + } 100 100 + #endif

+562

search/main.go

··· 1 1 + package main 2 2 + 3 3 + import ( 4 4 + "C" 5 5 + "fmt" 6 6 + "unsafe" 7 7 + 8 8 + "github.com/blevesearch/bleve/v2" 9 9 + "github.com/mitchellh/go-homedir" 10 10 + "github.com/mitchellh/mapstructure" 11 11 + pb "github.com/tsirysndr/rockbox-zig/search/gen/rockbox/search/v1alpha1" 12 12 + "google.golang.org/protobuf/proto" 13 13 + ) 14 14 + import ( 15 15 + "strings" 16 16 + "sync" 17 17 + ) 18 18 + 19 19 + func main() { 20 20 + } 21 21 + 22 22 + func buildBlevePath(name string) string { 23 23 + homedir, _ := homedir.Dir() 24 24 + rockboxDir := homedir + "/.config/rockbox.org" 25 25 + return rockboxDir + "/" + name + ".bleve" 26 26 + } 27 27 + 28 28 + func setupBleve(name string) (bleve.Index, error) { 29 29 + blevePath := buildBlevePath(name) 30 30 + mapping := bleve.NewIndexMapping() 31 31 + index, err := bleve.New(blevePath, mapping) 32 32 + 33 33 + if err == bleve.ErrorIndexPathExists { 34 34 + index, err = bleve.Open(blevePath) 35 35 + } 36 36 + 37 37 + return index, err 38 38 + } 39 39 + 40 40 + //export IndexAlbum 41 41 + func IndexAlbum(data *C.char, size C.int) { 42 42 + index, err := setupBleve("albums") 43 43 + if err != nil { 44 44 + panic(err) 45 45 + } 46 46 + 47 47 + messageBytes := C.GoBytes(unsafe.Pointer(data), size) 48 48 + var message pb.Album 49 49 + 50 50 + if err := proto.Unmarshal(messageBytes, &message); err != nil { 51 51 + fmt.Println(err) 52 52 + return 53 53 + } 54 54 + 55 55 + defer index.Close() 56 56 + 57 57 + index.Index(message.Id, message) 58 58 + } 59 59 + 60 60 + //export IndexArtist 61 61 + func IndexArtist(data *C.char, size C.int) { 62 62 + index, err := setupBleve("artists") 63 63 + if err != nil { 64 64 + panic(err) 65 65 + } 66 66 + 67 67 + messageBytes := C.GoBytes(unsafe.Pointer(data), size) 68 68 + var message pb.Artist 69 69 + 70 70 + if err := proto.Unmarshal(messageBytes, &message); err != nil { 71 71 + fmt.Println(err) 72 72 + return 73 73 + } 74 74 + 75 75 + defer index.Close() 76 76 + 77 77 + index.Index(message.Id, message) 78 78 + } 79 79 + 80 80 + //export IndexFile 81 81 + func IndexFile(data *C.char, size C.int) { 82 82 + index, err := setupBleve("files") 83 83 + if err != nil { 84 84 + panic(err) 85 85 + } 86 86 + 87 87 + messageBytes := C.GoBytes(unsafe.Pointer(data), size) 88 88 + var message pb.File 89 89 + 90 90 + if err := proto.Unmarshal(messageBytes, &message); err != nil { 91 91 + fmt.Println(err) 92 92 + return 93 93 + } 94 94 + 95 95 + defer index.Close() 96 96 + 97 97 + index.Index(message.Id, message) 98 98 + } 99 99 + 100 100 + //export IndexPlaylist 101 101 + func IndexPlaylist() { 102 102 + } 103 103 + 104 104 + //export IndexLikedTrack 105 105 + func IndexLikedTrack(data *C.char, size C.int) { 106 106 + index, err := setupBleve("liked_tracks") 107 107 + if err != nil { 108 108 + panic(err) 109 109 + } 110 110 + 111 111 + messageBytes := C.GoBytes(unsafe.Pointer(data), size) 112 112 + var message pb.Track 113 113 + 114 114 + if err := proto.Unmarshal(messageBytes, &message); err != nil { 115 115 + fmt.Println(err) 116 116 + return 117 117 + } 118 118 + 119 119 + defer index.Close() 120 120 + 121 121 + index.Index(message.Id, message) 122 122 + } 123 123 + 124 124 + //export IndexLikedAlbum 125 125 + func IndexLikedAlbum(data *C.char, size C.int) { 126 126 + index, err := setupBleve("liked_albums") 127 127 + if err != nil { 128 128 + panic(err) 129 129 + } 130 130 + 131 131 + messageBytes := C.GoBytes(unsafe.Pointer(data), size) 132 132 + var message pb.Album 133 133 + 134 134 + if err := proto.Unmarshal(messageBytes, &message); err != nil { 135 135 + fmt.Println(err) 136 136 + return 137 137 + } 138 138 + 139 139 + defer index.Close() 140 140 + 141 141 + index.Index(message.Id, message) 142 142 + } 143 143 + 144 144 + //export IndexTrack 145 145 + func IndexTrack(data *C.char, size C.int) { 146 146 + index, err := setupBleve("tracks") 147 147 + if err != nil { 148 148 + panic(err) 149 149 + } 150 150 + 151 151 + messageBytes := C.GoBytes(unsafe.Pointer(data), size) 152 152 + var message pb.Track 153 153 + 154 154 + if err := proto.Unmarshal(messageBytes, &message); err != nil { 155 155 + fmt.Println(err) 156 156 + return 157 157 + } 158 158 + 159 159 + defer index.Close() 160 160 + 161 161 + err = index.Index(message.Id, message) 162 162 + fmt.Println(err) 163 163 + } 164 164 + 165 165 + //export IndexAlbums 166 166 + func IndexAlbums(data *C.char, size C.int) { 167 167 + index, err := setupBleve("albums") 168 168 + if err != nil { 169 169 + panic(err) 170 170 + } 171 171 + 172 172 + messageBytes := C.GoBytes(unsafe.Pointer(data), size) 173 173 + var message pb.AlbumList 174 174 + 175 175 + if err := proto.Unmarshal(messageBytes, &message); err != nil { 176 176 + fmt.Println(err) 177 177 + return 178 178 + } 179 179 + 180 180 + var wg sync.WaitGroup 181 181 + defer index.Close() 182 182 + 183 183 + for _, album := range message.Albums { 184 184 + wg.Add(1) 185 185 + go func(album *pb.Album) { 186 186 + defer wg.Done() 187 187 + err := index.Index(album.Id, album) 188 188 + if err != nil { 189 189 + fmt.Printf("Failed to index album %s: %v\n", album.Id, err) 190 190 + } 191 191 + }(album) 192 192 + } 193 193 + 194 194 + wg.Wait() 195 195 + } 196 196 + 197 197 + //export IndexArtists 198 198 + func IndexArtists(data *C.char, size C.int) { 199 199 + index, err := setupBleve("artists") 200 200 + if err != nil { 201 201 + panic(err) 202 202 + } 203 203 + 204 204 + messageBytes := C.GoBytes(unsafe.Pointer(data), size) 205 205 + var message pb.ArtistList 206 206 + 207 207 + if err := proto.Unmarshal(messageBytes, &message); err != nil { 208 208 + fmt.Println(err) 209 209 + return 210 210 + } 211 211 + 212 212 + var wg sync.WaitGroup 213 213 + defer index.Close() 214 214 + 215 215 + for _, artist := range message.Artists { 216 216 + wg.Add(1) 217 217 + go func(artist *pb.Artist) { 218 218 + defer wg.Done() 219 219 + err := index.Index(artist.Id, artist) 220 220 + if err != nil { 221 221 + fmt.Printf("Failed to index artist %s: %v\n", artist.Id, err) 222 222 + } 223 223 + }(artist) 224 224 + } 225 225 + 226 226 + wg.Wait() 227 227 + } 228 228 + 229 229 + //export IndexFiles 230 230 + func IndexFiles(data *C.char, size C.int) { 231 231 + index, err := setupBleve("files") 232 232 + if err != nil { 233 233 + panic(err) 234 234 + } 235 235 + 236 236 + messageBytes := C.GoBytes(unsafe.Pointer(data), size) 237 237 + var message pb.FileList 238 238 + 239 239 + if err := proto.Unmarshal(messageBytes, &message); err != nil { 240 240 + fmt.Println(err) 241 241 + return 242 242 + } 243 243 + 244 244 + var wg sync.WaitGroup 245 245 + defer index.Close() 246 246 + 247 247 + for _, file := range message.Files { 248 248 + wg.Add(1) 249 249 + go func(file *pb.File) { 250 250 + defer wg.Done() 251 251 + err := index.Index(file.Id, file) 252 252 + if err != nil { 253 253 + fmt.Printf("Failed to index file %s: %v\n", file.Id, err) 254 254 + } 255 255 + }(file) 256 256 + } 257 257 + 258 258 + wg.Wait() 259 259 + } 260 260 + 261 261 + //export IndexPlaylists 262 262 + func IndexPlaylists() { 263 263 + } 264 264 + 265 265 + //export IndexLikedTracks 266 266 + func IndexLikedTracks(data *C.char, size C.int) { 267 267 + index, err := setupBleve("liked_tracks") 268 268 + if err != nil { 269 269 + panic(err) 270 270 + } 271 271 + 272 272 + messageBytes := C.GoBytes(unsafe.Pointer(data), size) 273 273 + var message pb.LikedTrackList 274 274 + 275 275 + if err := proto.Unmarshal(messageBytes, &message); err != nil { 276 276 + fmt.Println(err) 277 277 + return 278 278 + } 279 279 + 280 280 + var wg sync.WaitGroup 281 281 + defer index.Close() 282 282 + 283 283 + for _, track := range message.Tracks { 284 284 + wg.Add(1) 285 285 + go func(track *pb.LikedTrack) { 286 286 + defer wg.Done() 287 287 + err := index.Index(track.Id, track) 288 288 + if err != nil { 289 289 + fmt.Printf("Failed to index track %s: %v\n", track.Id, err) 290 290 + } 291 291 + }(track) 292 292 + } 293 293 + 294 294 + wg.Wait() 295 295 + } 296 296 + 297 297 + //export IndexLikedAlbums 298 298 + func IndexLikedAlbums(data *C.char, size C.int) { 299 299 + index, err := setupBleve("liked_albums") 300 300 + if err != nil { 301 301 + panic(err) 302 302 + } 303 303 + 304 304 + messageBytes := C.GoBytes(unsafe.Pointer(data), size) 305 305 + var message pb.LikedAlbumList 306 306 + 307 307 + if err := proto.Unmarshal(messageBytes, &message); err != nil { 308 308 + fmt.Println(err) 309 309 + return 310 310 + } 311 311 + 312 312 + var wg sync.WaitGroup 313 313 + defer index.Close() 314 314 + 315 315 + for _, album := range message.Albums { 316 316 + wg.Add(1) 317 317 + go func(album *pb.LikedAlbum) { 318 318 + defer wg.Done() 319 319 + err := index.Index(album.Id, album) 320 320 + if err != nil { 321 321 + fmt.Printf("Failed to index album %s: %v\n", album.Id, err) 322 322 + } 323 323 + }(album) 324 324 + } 325 325 + 326 326 + wg.Wait() 327 327 + } 328 328 + 329 329 + //export IndexTracks 330 330 + func IndexTracks(data *C.char, size C.int) { 331 331 + index, err := setupBleve("tracks") 332 332 + if err != nil { 333 333 + panic(err) 334 334 + } 335 335 + 336 336 + messageBytes := C.GoBytes(unsafe.Pointer(data), size) 337 337 + var message pb.TrackList 338 338 + 339 339 + if err := proto.Unmarshal(messageBytes, &message); err != nil { 340 340 + fmt.Println(err) 341 341 + return 342 342 + } 343 343 + 344 344 + // Use WaitGroup to ensure all goroutines finish before closing the index 345 345 + var wg sync.WaitGroup 346 346 + defer index.Close() 347 347 + 348 348 + for _, track := range message.Tracks { 349 349 + wg.Add(1) 350 350 + // Launch goroutine to index each track 351 351 + go func(track *pb.Track) { 352 352 + defer wg.Done() 353 353 + err := index.Index(track.Id, track) 354 354 + if err != nil { 355 355 + fmt.Printf("Failed to index track %s: %v\n", track.Id, err) 356 356 + } 357 357 + }(track) 358 358 + } 359 359 + 360 360 + // Wait for all goroutines to finish 361 361 + wg.Wait() 362 362 + } 363 363 + 364 364 + //export SearchAlbum 365 365 + func SearchAlbum(term *C.char) *C.char { 366 366 + index, err := setupBleve("albums") 367 367 + if err != nil { 368 368 + panic(err) 369 369 + } 370 370 + 371 371 + defer index.Close() 372 372 + 373 373 + query := bleve.NewPrefixQuery(C.GoString(term)) 374 374 + searchRequest := bleve.NewSearchRequest(query) 375 375 + 376 376 + if strings.Contains(C.GoString(term), " ") { 377 377 + query := bleve.NewMatchQuery(C.GoString(term)) 378 378 + searchRequest = bleve.NewSearchRequest(query) 379 379 + } 380 380 + 381 381 + searchRequest.Fields = []string{"*"} 382 382 + searchResult, _ := index.Search(searchRequest) 383 383 + // b, _ := json.MarshalIndent(searchResult, "", " ") 384 384 + // fmt.Println(string(b)) 385 385 + 386 386 + var results []*pb.Album 387 387 + for _, hit := range searchResult.Hits { 388 388 + var album pb.Album 389 389 + _ = mapstructure.Decode(hit.Fields, &album) 390 390 + results = append(results, &album) 391 391 + } 392 392 + 393 393 + response, _ := proto.Marshal(&pb.AlbumList{Albums: results}) 394 394 + 395 395 + return C.CString(string(response)) 396 396 + } 397 397 + 398 398 + //export SearchArtist 399 399 + func SearchArtist(term *C.char) *C.char { 400 400 + index, err := setupBleve("artists") 401 401 + if err != nil { 402 402 + panic(err) 403 403 + } 404 404 + 405 405 + defer index.Close() 406 406 + 407 407 + query := bleve.NewPrefixQuery(C.GoString(term)) 408 408 + searchRequest := bleve.NewSearchRequest(query) 409 409 + 410 410 + if strings.Contains(C.GoString(term), " ") { 411 411 + query := bleve.NewMatchQuery(C.GoString(term)) 412 412 + searchRequest = bleve.NewSearchRequest(query) 413 413 + } 414 414 + 415 415 + searchRequest.Fields = []string{"*"} 416 416 + searchResult, _ := index.Search(searchRequest) 417 417 + // b, _ := json.MarshalIndent(searchResult, "", " ") 418 418 + // fmt.Println(string(b)) 419 419 + 420 420 + var results []*pb.Artist 421 421 + for _, hit := range searchResult.Hits { 422 422 + var artist pb.Artist 423 423 + _ = mapstructure.Decode(hit.Fields, &artist) 424 424 + results = append(results, &artist) 425 425 + } 426 426 + 427 427 + response, _ := proto.Marshal(&pb.ArtistList{Artists: results}) 428 428 + 429 429 + return C.CString(string(response)) 430 430 + } 431 431 + 432 432 + //export SearchFile 433 433 + func SearchFile(term *C.char) *C.char { 434 434 + index, err := setupBleve("files") 435 435 + if err != nil { 436 436 + panic(err) 437 437 + } 438 438 + 439 439 + defer index.Close() 440 440 + 441 441 + query := bleve.NewPrefixQuery(C.GoString(term)) 442 442 + searchRequest := bleve.NewSearchRequest(query) 443 443 + 444 444 + if strings.Contains(C.GoString(term), " ") { 445 445 + query := bleve.NewMatchQuery(C.GoString(term)) 446 446 + searchRequest = bleve.NewSearchRequest(query) 447 447 + } 448 448 + 449 449 + searchRequest.Fields = []string{"*"} 450 450 + searchResult, _ := index.Search(searchRequest) 451 451 + 452 452 + var results []*pb.File 453 453 + 454 454 + for _, hit := range searchResult.Hits { 455 455 + var file pb.File 456 456 + _ = mapstructure.Decode(hit.Fields, &file) 457 457 + results = append(results, &file) 458 458 + } 459 459 + 460 460 + response, _ := proto.Marshal(&pb.FileList{Files: results}) 461 461 + 462 462 + return C.CString(string(response)) 463 463 + } 464 464 + 465 465 + //export SearchTrack 466 466 + func SearchTrack(term *C.char) *C.char { 467 467 + index, err := setupBleve("tracks") 468 468 + if err != nil { 469 469 + panic(err) 470 470 + } 471 471 + 472 472 + defer index.Close() 473 473 + 474 474 + query := bleve.NewPrefixQuery(C.GoString(term)) 475 475 + searchRequest := bleve.NewSearchRequest(query) 476 476 + 477 477 + if strings.Contains(C.GoString(term), " ") { 478 478 + query := bleve.NewMatchQuery(C.GoString(term)) 479 479 + searchRequest = bleve.NewSearchRequest(query) 480 480 + } 481 481 + 482 482 + searchRequest.Fields = []string{"*"} 483 483 + searchResult, _ := index.Search(searchRequest) 484 484 + 485 485 + var results []*pb.Track 486 486 + 487 487 + for _, hit := range searchResult.Hits { 488 488 + var track pb.Track 489 489 + _ = mapstructure.Decode(hit.Fields, &track) 490 490 + results = append(results, &track) 491 491 + } 492 492 + 493 493 + response, _ := proto.Marshal(&pb.TrackList{Tracks: results}) 494 494 + 495 495 + return C.CString(string(response)) 496 496 + } 497 497 + 498 498 + //export SearchLikedTrack 499 499 + func SearchLikedTrack(term *C.char) *C.char { 500 500 + index, err := setupBleve("liked_tracks") 501 501 + if err != nil { 502 502 + panic(err) 503 503 + } 504 504 + 505 505 + defer index.Close() 506 506 + 507 507 + query := bleve.NewPrefixQuery(C.GoString(term)) 508 508 + searchRequest := bleve.NewSearchRequest(query) 509 509 + 510 510 + if strings.Contains(C.GoString(term), " ") { 511 511 + query := bleve.NewMatchQuery(C.GoString(term)) 512 512 + searchRequest = bleve.NewSearchRequest(query) 513 513 + } 514 514 + 515 515 + searchRequest.Fields = []string{"*"} 516 516 + searchResult, _ := index.Search(searchRequest) 517 517 + 518 518 + var results []*pb.LikedTrack 519 519 + 520 520 + for _, hit := range searchResult.Hits { 521 521 + var track pb.LikedTrack 522 522 + _ = mapstructure.Decode(hit.Fields, &track) 523 523 + results = append(results, &track) 524 524 + } 525 525 + 526 526 + response, _ := proto.Marshal(&pb.LikedTrackList{Tracks: results}) 527 527 + 528 528 + return C.CString(string(response)) 529 529 + } 530 530 + 531 531 + //export SearchLikedAlbum 532 532 + func SearchLikedAlbum(term *C.char) *C.char { 533 533 + index, err := setupBleve("liked_albums") 534 534 + if err != nil { 535 535 + panic(err) 536 536 + } 537 537 + 538 538 + defer index.Close() 539 539 + 540 540 + query := bleve.NewPrefixQuery(C.GoString(term)) 541 541 + searchRequest := bleve.NewSearchRequest(query) 542 542 + 543 543 + if strings.Contains(C.GoString(term), " ") { 544 544 + query := bleve.NewMatchQuery(C.GoString(term)) 545 545 + searchRequest = bleve.NewSearchRequest(query) 546 546 + } 547 547 + 548 548 + searchRequest.Fields = []string{"*"} 549 549 + searchResult, _ := index.Search(searchRequest) 550 550 + 551 551 + var results []*pb.LikedAlbum 552 552 + 553 553 + for _, hit := range searchResult.Hits { 554 554 + var album pb.LikedAlbum 555 555 + _ = mapstructure.Decode(hit.Fields, &album) 556 556 + results = append(results, &album) 557 557 + } 558 558 + 559 559 + response, _ := proto.Marshal(&pb.LikedAlbumList{Albums: results}) 560 560 + 561 561 + return C.CString(string(response)) 562 562 + }

+8

search/proto/buf.gen.yaml

··· 1 1 + version: v2 2 2 + clean: true 3 3 + plugins: 4 4 + - local: protoc-gen-go 5 5 + out: ../gen 6 6 + opt: paths=source_relative 7 7 + inputs: 8 8 + - directory: .

+11

search/proto/buf.yml

··· 1 1 + # For details on buf.yaml configuration, visit https://buf.build/docs/configuration/v2/buf-yaml 2 2 + version: v2 3 3 + modules: 4 4 + - path: . 5 5 + name: buf.build/tsiry/rockboxapis 6 6 + lint: 7 7 + use: 8 8 + - STANDARD 9 9 + breaking: 10 10 + use: 11 11 + - FILE

+20

search/proto/rockbox/search/v1alpha1/album.proto

··· 1 1 + syntax = "proto3"; 2 2 + 3 3 + package rockbox.search.v1alpha1; 4 4 + 5 5 + option go_package = "github.com/tsirysndr/rockbox-zig/gen/rockbox/search/v1alpha1"; 6 6 + 7 7 + message Album { 8 8 + string id = 1; 9 9 + string title = 2; 10 10 + string artist = 3; 11 11 + uint32 year = 4; 12 12 + string year_string = 5; 13 13 + optional string album_art = 6; 14 14 + string md5 = 7; 15 15 + string artist_id = 8; 16 16 + } 17 17 + 18 18 + message AlbumList { 19 19 + repeated Album albums = 1; 20 20 + }

+20

search/proto/rockbox/search/v1alpha1/all.proto

··· 1 1 + syntax = "proto3"; 2 2 + 3 3 + package rockbox.search.v1alpha1; 4 4 + 5 5 + import "rockbox/search/v1alpha1/album.proto"; 6 6 + import "rockbox/search/v1alpha1/artist.proto"; 7 7 + import "rockbox/search/v1alpha1/file.proto"; 8 8 + import "rockbox/search/v1alpha1/like.proto"; 9 9 + import "rockbox/search/v1alpha1/track.proto"; 10 10 + 11 11 + option go_package = "github.com/tsirysndr/rockbox-zig/gen/rockbox/search/v1alpha1"; 12 12 + 13 13 + message All { 14 14 + repeated rockbox.search.v1alpha1.Album albums = 1; 15 15 + repeated rockbox.search.v1alpha1.Artist artists = 2; 16 16 + repeated rockbox.search.v1alpha1.File files = 3; 17 17 + repeated rockbox.search.v1alpha1.LikedAlbum liked_albums = 4; 18 18 + repeated rockbox.search.v1alpha1.LikedTrack liked_track = 5; 19 19 + repeated rockbox.search.v1alpha1.Track tracks = 6; 20 20 + }

+16

search/proto/rockbox/search/v1alpha1/artist.proto

··· 1 1 + syntax = "proto3"; 2 2 + 3 3 + package rockbox.search.v1alpha1; 4 4 + 5 5 + option go_package = "github.com/tsirysndr/rockbox-zig/gen/rockbox/search/v1alpha1"; 6 6 + 7 7 + message Artist { 8 8 + string id = 1; 9 9 + string name = 2; 10 10 + optional string bio = 3; 11 11 + optional string image = 4; 12 12 + } 13 13 + 14 14 + message ArtistList { 15 15 + repeated Artist artists = 1; 16 16 + }

+16

search/proto/rockbox/search/v1alpha1/file.proto

··· 1 1 + syntax = "proto3"; 2 2 + 3 3 + package rockbox.search.v1alpha1; 4 4 + 5 5 + option go_package = "github.com/tsirysndr/rockbox-zig/gen/rockbox/search/v1alpha1"; 6 6 + 7 7 + message File { 8 8 + string id = 1; 9 9 + string name = 2; 10 10 + uint32 time_write = 4; 11 11 + bool is_directory = 5; 12 12 + } 13 13 + 14 14 + message FileList { 15 15 + repeated File files = 1; 16 16 + }

+50

search/proto/rockbox/search/v1alpha1/like.proto

··· 1 1 + syntax = "proto3"; 2 2 + 3 3 + package rockbox.search.v1alpha1; 4 4 + 5 5 + option go_package = "github.com/tsirysndr/rockbox-zig/gen/rockbox/search/v1alpha1"; 6 6 + 7 7 + message LikedAlbum { 8 8 + string id = 1; 9 9 + string title = 2; 10 10 + string artist = 3; 11 11 + uint32 year = 4; 12 12 + string year_string = 5; 13 13 + optional string album_art = 6; 14 14 + string md5 = 7; 15 15 + string artist_id = 8; 16 16 + } 17 17 + 18 18 + message LikedTrack { 19 19 + string id = 1; 20 20 + string path = 2; 21 21 + string title = 3; 22 22 + string artist = 4; 23 23 + string album = 5; 24 24 + string album_artist = 6; 25 25 + uint32 bitrate = 7; 26 26 + string composer = 8; 27 27 + uint32 disc_number = 9; 28 28 + uint32 filesize = 10; 29 29 + uint32 frequency = 11; 30 30 + uint32 length = 12; 31 31 + uint32 track_number = 13; 32 32 + uint32 year = 14; 33 33 + string year_string = 15; 34 34 + string genre = 16; 35 35 + string md5 = 17; 36 36 + optional string album_art = 18; 37 37 + optional string artist_id = 19; 38 38 + optional string album_id = 20; 39 39 + optional string genre_id = 21; 40 40 + string created_at = 22; 41 41 + string updated_at = 23; 42 42 + } 43 43 + 44 44 + message LikedAlbumList { 45 45 + repeated LikedAlbum albums = 1; 46 46 + } 47 47 + 48 48 + message LikedTrackList { 49 49 + repeated LikedTrack tracks = 1; 50 50 + }

+35

search/proto/rockbox/search/v1alpha1/track.proto

··· 1 1 + syntax = "proto3"; 2 2 + 3 3 + package rockbox.search.v1alpha1; 4 4 + 5 5 + option go_package = "github.com/tsirysndr/rockbox-zig/gen/rockbox/search/v1alpha1"; 6 6 + 7 7 + message Track { 8 8 + string id = 1; 9 9 + string path = 2; 10 10 + string title = 3; 11 11 + string artist = 4; 12 12 + string album = 5; 13 13 + string album_artist = 6; 14 14 + uint32 bitrate = 7; 15 15 + string composer = 8; 16 16 + uint32 disc_number = 9; 17 17 + uint32 filesize = 10; 18 18 + uint32 frequency = 11; 19 19 + uint32 length = 12; 20 20 + uint32 track_number = 13; 21 21 + uint32 year = 14; 22 22 + string year_string = 15; 23 23 + string genre = 16; 24 24 + string md5 = 17; 25 25 + optional string album_art = 18; 26 26 + optional string artist_id = 19; 27 27 + optional string album_id = 20; 28 28 + optional string genre_id = 21; 29 29 + string created_at = 22; 30 30 + string updated_at = 23; 31 31 + } 32 32 + 33 33 + message TrackList { 34 34 + repeated Track tracks = 1; 35 35 + }

+10 -2

tools/root.make

··· 412 412 413 413 ziginstall: zig 414 414 @echo "Installing your build in your '$(RBPREFIX)' dir" 415 415 - cd .. && zig build install-rockbox && mkdir -p $(RBPREFIX)/bin $(RBPREFIX)/share/rockbox && cp zig-out/bin/rockbox $(RBPREFIX)/bin && cp -r assets/* $(RBPREFIX)/share/rockbox 415 415 + cd .. \ 416 416 + && zig build install-rockbox \ 417 417 + && mkdir -p $(RBPREFIX)/bin $(RBPREFIX)/share/rockbox \ 418 418 + && cp zig-out/bin/rockbox $(RBPREFIX)/bin \ 419 419 + && cp -r assets/* $(RBPREFIX)/share/rockbox 416 420 417 421 symlinkinstall: simext1 418 422 @echo "Installing a full setup with links in your '$(RBPREFIX)' dir" ··· 424 428 $(SILENT)$(CC) $(CFLAGS) -c -o $(BUILDDIR)/apps/recorder/jpeg_load.o $(ROOTDIR)/apps/recorder/jpeg_load.c 425 429 426 430 zig: $(BUILDDIR)/apps/recorder/jpeg_load.o $(BUILDDIR)/lang/lang.h $(BUILDDIR)/lang_enum.h $(BUILDDIR)/lang/lang_core.c $(BUILDDIR)/lang/max_language_size.h $(BUILDDIR)/sysfont.o $(BUILDDIR)/rbversion.h $(PBMPHFILES) $(LUA_BUILDDIR)/actions.lua $(LUA_BUILDDIR)/settings.lua $(LUA_BUILDDIR)/buttons.lua $(LUA_BUILDDIR)/rb_defines.lua $(LUA_BUILDDIR)/sound_defines.lua $(LUA_BUILDDIR)/rocklib_aux.c $(BUILDDIR)/credits.raw credits.raw $(DEPFILE) $(TOOLS) $(CODECS) 427 427 - cd .. && cargo build -p rockbox-cli --release && cargo build -p rockbox-server --release && zig build all 431 431 + cd .. \ 432 432 + && cargo build -p rockbox-cli --release \ 433 433 + && cargo build -p rockbox-server --release \ 434 434 + && cd search && go build -buildmode=c-archive -o librockboxsearch.a \ 435 435 + && cd .. && zig build all 428 436 help: 429 437 @echo "A few helpful make targets" 430 438 @echo ""

+1 -1

webui/rockbox/src/Components/ControlBar/PlayQueue/PlayQueue.tsx

··· 113 113 position: "absolute", 114 114 top: 0, 115 115 left: 0, 116 116 - width: "calc(100% - 34px)", 116 116 + width: "calc(100% - 12px)", 117 117 transform: `translateY(${virtualItem.start}px)`, 118 118 }} 119 119 >

+1 -1

webui/rockbox/src/Components/ControlBar/PlayQueue/__snapshots__/PlayQueue.test.tsx.snap

··· 31 31 </div> 32 32 </div> 33 33 <div 34 34 - class="css-1wmblyr" 34 34 + class="css-1nzjdw3" 35 35 > 36 36 <div 37 37 style="height: 192px; width: 100%; position: relative;"

+2

webui/rockbox/src/Components/ControlBar/PlayQueue/styles.tsx

··· 33 33 export const List = styled.div` 34 34 height: calc(100% - 59.5px); 35 35 overflow-y: auto; 36 36 + overflow-x: hidden; 36 37 `; 37 38 38 39 export const ListItem = styled.div` ··· 95 96 background-color: transparent; 96 97 cursor: pointer; 97 98 border: none; 99 99 + margin-right: 10px; 98 100 `; 99 101 100 102 export const Placeholder = styled.div`

+1

webui/rockbox/src/Components/Files/FilesWithData.tsx

··· 28 28 playDirectory({ 29 29 variables: { 30 30 path, 31 31 + recurse: true, 31 32 }, 32 33 }); 33 34 };