+6 -6

Cargo.lock

reviewed

··· 9965 9965 9966 9966 [[package]] 9967 9967 name = "serde" 9968 9968 - version = "1.0.228" 9968 9968 + version = "1.0.220" 9969 9969 source = "registry+https://github.com/rust-lang/crates.io-index" 9970 9970 - checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" 9970 9970 + checksum = "ceecad4c782e936ac90ecfd6b56532322e3262b14320abf30ce89a92ffdbfe22" 9971 9971 dependencies = [ 9972 9972 "serde_core", 9973 9973 "serde_derive", ··· 10005 10005 10006 10006 [[package]] 10007 10007 name = "serde_core" 10008 10008 - version = "1.0.228" 10008 10008 + version = "1.0.220" 10009 10009 source = "registry+https://github.com/rust-lang/crates.io-index" 10010 10010 - checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" 10010 10010 + checksum = "ddba47394f3b862d6ff6efdbd26ca4673e3566a307880a0ffb98f274bbe0ec32" 10011 10011 dependencies = [ 10012 10012 "serde_derive", 10013 10013 ] 10014 10014 10015 10015 [[package]] 10016 10016 name = "serde_derive" 10017 10017 - version = "1.0.228" 10017 10017 + version = "1.0.220" 10018 10018 source = "registry+https://github.com/rust-lang/crates.io-index" 10019 10019 - checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" 10019 10019 + checksum = "60e1f3b1761e96def5ec6d04a6e7421c0404fa3cf5c0155f1e2848fae3d8cc08" 10020 10020 dependencies = [ 10021 10021 "proc-macro2", 10022 10022 "quote",

+1 -1

Cargo.toml

reviewed

··· 127 127 saffron = "=0.1.0" 128 128 scopeguard = "1.2.0" 129 129 sec1 = "0.7" 130 130 - serde = { version = "1.0.149", features = ["derive"] } 130 130 + serde = { version = ">=1.0.149, <1.0.225", features = ["derive"] } 131 131 serde_bytes = "0.11" 132 132 serde_json = "1.0.85" 133 133 serde_repr = "=0.1.19"

+1 -1

cli/Cargo.toml

reviewed

··· 27 27 "rustls-tls", 28 28 "json", 29 29 ], default-features = false } 30 30 - serde = { version = "1.0.210", features = ["derive"] } 30 30 + serde = { version = ">=1.0.210, <1.0.225", features = ["derive"] } 31 31 serde_json = "1.0.128" 32 32 open = "5.3.2" 33 33 warp = "0.3.7"

+2532 -1255

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

reviewed

··· 43 43 dead_code, 44 44 missing_docs, 45 45 clippy::wildcard_imports, 46 46 - clippy::let_unit_value 46 46 + clippy::let_unit_value, 47 47 )] 48 48 - use tonic::codegen::http::Uri; 49 48 use tonic::codegen::*; 49 49 + use tonic::codegen::http::Uri; 50 50 #[derive(Debug, Clone)] 51 51 pub struct BrowseServiceClient<T> { 52 52 inner: tonic::client::Grpc<T>, ··· 90 90 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 91 91 >, 92 92 >, 93 93 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 94 94 - Into<StdError> + std::marker::Send + std::marker::Sync, 93 93 + <T as tonic::codegen::Service< 94 94 + http::Request<tonic::body::BoxBody>, 95 95 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 95 96 { 96 97 BrowseServiceClient::new(InterceptedService::new(inner, interceptor)) 97 98 } ··· 129 130 pub async fn tree_get_entries( 130 131 &mut self, 131 132 request: impl tonic::IntoRequest<super::TreeGetEntriesRequest>, 132 132 - ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status> 133 133 - { 134 134 - self.inner.ready().await.map_err(|e| { 135 135 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 136 136 - })?; 133 133 + ) -> std::result::Result< 134 134 + tonic::Response<super::TreeGetEntriesResponse>, 135 135 + tonic::Status, 136 136 + > { 137 137 + self.inner 138 138 + .ready() 139 139 + .await 140 140 + .map_err(|e| { 141 141 + tonic::Status::unknown( 142 142 + format!("Service was not ready: {}", e.into()), 143 143 + ) 144 144 + })?; 137 145 let codec = tonic::codec::ProstCodec::default(); 138 146 let path = http::uri::PathAndQuery::from_static( 139 147 "/rockbox.v1alpha1.BrowseService/TreeGetEntries", 140 148 ); 141 149 let mut req = request.into_request(); 142 142 - req.extensions_mut().insert(GrpcMethod::new( 143 143 - "rockbox.v1alpha1.BrowseService", 144 144 - "TreeGetEntries", 145 145 - )); 150 150 + req.extensions_mut() 151 151 + .insert( 152 152 + GrpcMethod::new("rockbox.v1alpha1.BrowseService", "TreeGetEntries"), 153 153 + ); 146 154 self.inner.unary(req, path, codec).await 147 155 } 148 156 } ··· 154 162 dead_code, 155 163 missing_docs, 156 164 clippy::wildcard_imports, 157 157 - clippy::let_unit_value 165 165 + clippy::let_unit_value, 158 166 )] 159 167 use tonic::codegen::*; 160 168 /// Generated trait containing gRPC methods that should be implemented for use with BrowseServiceServer. ··· 163 171 async fn tree_get_entries( 164 172 &self, 165 173 request: tonic::Request<super::TreeGetEntriesRequest>, 166 166 - ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status>; 174 174 + ) -> std::result::Result< 175 175 + tonic::Response<super::TreeGetEntriesResponse>, 176 176 + tonic::Status, 177 177 + >; 167 178 } 168 179 #[derive(Debug)] 169 180 pub struct BrowseServiceServer<T> { ··· 186 197 max_encoding_message_size: None, 187 198 } 188 199 } 189 189 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 200 200 + pub fn with_interceptor<F>( 201 201 + inner: T, 202 202 + interceptor: F, 203 203 + ) -> InterceptedService<Self, F> 190 204 where 191 205 F: tonic::service::Interceptor, 192 206 { ··· 241 255 "/rockbox.v1alpha1.BrowseService/TreeGetEntries" => { 242 256 #[allow(non_camel_case_types)] 243 257 struct TreeGetEntriesSvc<T: BrowseService>(pub Arc<T>); 244 244 - impl<T: BrowseService> tonic::server::UnaryService<super::TreeGetEntriesRequest> 245 245 - for TreeGetEntriesSvc<T> 246 246 - { 258 258 + impl< 259 259 + T: BrowseService, 260 260 + > tonic::server::UnaryService<super::TreeGetEntriesRequest> 261 261 + for TreeGetEntriesSvc<T> { 247 262 type Response = super::TreeGetEntriesResponse; 248 248 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 263 263 + type Future = BoxFuture< 264 264 + tonic::Response<Self::Response>, 265 265 + tonic::Status, 266 266 + >; 249 267 fn call( 250 268 &mut self, 251 269 request: tonic::Request<super::TreeGetEntriesRequest>, 252 270 ) -> Self::Future { 253 271 let inner = Arc::clone(&self.0); 254 272 let fut = async move { 255 255 - <T as BrowseService>::tree_get_entries(&inner, request).await 273 273 + <T as BrowseService>::tree_get_entries(&inner, request) 274 274 + .await 256 275 }; 257 276 Box::pin(fut) 258 277 } ··· 279 298 }; 280 299 Box::pin(fut) 281 300 } 282 282 - _ => Box::pin(async move { 283 283 - let mut response = http::Response::new(empty_body()); 284 284 - let headers = response.headers_mut(); 285 285 - headers.insert( 286 286 - tonic::Status::GRPC_STATUS, 287 287 - (tonic::Code::Unimplemented as i32).into(), 288 288 - ); 289 289 - headers.insert( 290 290 - http::header::CONTENT_TYPE, 291 291 - tonic::metadata::GRPC_CONTENT_TYPE, 292 292 - ); 293 293 - Ok(response) 294 294 - }), 301 301 + _ => { 302 302 + Box::pin(async move { 303 303 + let mut response = http::Response::new(empty_body()); 304 304 + let headers = response.headers_mut(); 305 305 + headers 306 306 + .insert( 307 307 + tonic::Status::GRPC_STATUS, 308 308 + (tonic::Code::Unimplemented as i32).into(), 309 309 + ); 310 310 + headers 311 311 + .insert( 312 312 + http::header::CONTENT_TYPE, 313 313 + tonic::metadata::GRPC_CONTENT_TYPE, 314 314 + ); 315 315 + Ok(response) 316 316 + }) 317 317 + } 295 318 } 296 319 } 297 320 } ··· 548 571 dead_code, 549 572 missing_docs, 550 573 clippy::wildcard_imports, 551 551 - clippy::let_unit_value 574 574 + clippy::let_unit_value, 552 575 )] 553 553 - use tonic::codegen::http::Uri; 554 576 use tonic::codegen::*; 577 577 + use tonic::codegen::http::Uri; 555 578 #[derive(Debug, Clone)] 556 579 pub struct LibraryServiceClient<T> { 557 580 inner: tonic::client::Grpc<T>, ··· 595 618 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 596 619 >, 597 620 >, 598 598 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 599 599 - Into<StdError> + std::marker::Send + std::marker::Sync, 621 621 + <T as tonic::codegen::Service< 622 622 + http::Request<tonic::body::BoxBody>, 623 623 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 600 624 { 601 625 LibraryServiceClient::new(InterceptedService::new(inner, interceptor)) 602 626 } ··· 634 658 pub async fn get_albums( 635 659 &mut self, 636 660 request: impl tonic::IntoRequest<super::GetAlbumsRequest>, 637 637 - ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status> { 638 638 - self.inner.ready().await.map_err(|e| { 639 639 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 640 640 - })?; 661 661 + ) -> std::result::Result< 662 662 + tonic::Response<super::GetAlbumsResponse>, 663 663 + tonic::Status, 664 664 + > { 665 665 + self.inner 666 666 + .ready() 667 667 + .await 668 668 + .map_err(|e| { 669 669 + tonic::Status::unknown( 670 670 + format!("Service was not ready: {}", e.into()), 671 671 + ) 672 672 + })?; 641 673 let codec = tonic::codec::ProstCodec::default(); 642 642 - let path = 643 643 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbums"); 674 674 + let path = http::uri::PathAndQuery::from_static( 675 675 + "/rockbox.v1alpha1.LibraryService/GetAlbums", 676 676 + ); 644 677 let mut req = request.into_request(); 645 645 - req.extensions_mut().insert(GrpcMethod::new( 646 646 - "rockbox.v1alpha1.LibraryService", 647 647 - "GetAlbums", 648 648 - )); 678 678 + req.extensions_mut() 679 679 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbums")); 649 680 self.inner.unary(req, path, codec).await 650 681 } 651 682 pub async fn get_artists( 652 683 &mut self, 653 684 request: impl tonic::IntoRequest<super::GetArtistsRequest>, 654 654 - ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status> 655 655 - { 656 656 - self.inner.ready().await.map_err(|e| { 657 657 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 658 658 - })?; 685 685 + ) -> std::result::Result< 686 686 + tonic::Response<super::GetArtistsResponse>, 687 687 + tonic::Status, 688 688 + > { 689 689 + self.inner 690 690 + .ready() 691 691 + .await 692 692 + .map_err(|e| { 693 693 + tonic::Status::unknown( 694 694 + format!("Service was not ready: {}", e.into()), 695 695 + ) 696 696 + })?; 659 697 let codec = tonic::codec::ProstCodec::default(); 660 660 - let path = 661 661 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtists"); 698 698 + let path = http::uri::PathAndQuery::from_static( 699 699 + "/rockbox.v1alpha1.LibraryService/GetArtists", 700 700 + ); 662 701 let mut req = request.into_request(); 663 663 - req.extensions_mut().insert(GrpcMethod::new( 664 664 - "rockbox.v1alpha1.LibraryService", 665 665 - "GetArtists", 666 666 - )); 702 702 + req.extensions_mut() 703 703 + .insert( 704 704 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtists"), 705 705 + ); 667 706 self.inner.unary(req, path, codec).await 668 707 } 669 708 pub async fn get_tracks( 670 709 &mut self, 671 710 request: impl tonic::IntoRequest<super::GetTracksRequest>, 672 672 - ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status> { 673 673 - self.inner.ready().await.map_err(|e| { 674 674 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 675 675 - })?; 711 711 + ) -> std::result::Result< 712 712 + tonic::Response<super::GetTracksResponse>, 713 713 + tonic::Status, 714 714 + > { 715 715 + self.inner 716 716 + .ready() 717 717 + .await 718 718 + .map_err(|e| { 719 719 + tonic::Status::unknown( 720 720 + format!("Service was not ready: {}", e.into()), 721 721 + ) 722 722 + })?; 676 723 let codec = tonic::codec::ProstCodec::default(); 677 677 - let path = 678 678 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTracks"); 724 724 + let path = http::uri::PathAndQuery::from_static( 725 725 + "/rockbox.v1alpha1.LibraryService/GetTracks", 726 726 + ); 679 727 let mut req = request.into_request(); 680 680 - req.extensions_mut().insert(GrpcMethod::new( 681 681 - "rockbox.v1alpha1.LibraryService", 682 682 - "GetTracks", 683 683 - )); 728 728 + req.extensions_mut() 729 729 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTracks")); 684 730 self.inner.unary(req, path, codec).await 685 731 } 686 732 pub async fn get_album( 687 733 &mut self, 688 734 request: impl tonic::IntoRequest<super::GetAlbumRequest>, 689 689 - ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status> { 690 690 - self.inner.ready().await.map_err(|e| { 691 691 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 692 692 - })?; 735 735 + ) -> std::result::Result< 736 736 + tonic::Response<super::GetAlbumResponse>, 737 737 + tonic::Status, 738 738 + > { 739 739 + self.inner 740 740 + .ready() 741 741 + .await 742 742 + .map_err(|e| { 743 743 + tonic::Status::unknown( 744 744 + format!("Service was not ready: {}", e.into()), 745 745 + ) 746 746 + })?; 693 747 let codec = tonic::codec::ProstCodec::default(); 694 694 - let path = 695 695 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbum"); 748 748 + let path = http::uri::PathAndQuery::from_static( 749 749 + "/rockbox.v1alpha1.LibraryService/GetAlbum", 750 750 + ); 696 751 let mut req = request.into_request(); 697 697 - req.extensions_mut().insert(GrpcMethod::new( 698 698 - "rockbox.v1alpha1.LibraryService", 699 699 - "GetAlbum", 700 700 - )); 752 752 + req.extensions_mut() 753 753 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbum")); 701 754 self.inner.unary(req, path, codec).await 702 755 } 703 756 pub async fn get_artist( 704 757 &mut self, 705 758 request: impl tonic::IntoRequest<super::GetArtistRequest>, 706 706 - ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status> { 707 707 - self.inner.ready().await.map_err(|e| { 708 708 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 709 709 - })?; 759 759 + ) -> std::result::Result< 760 760 + tonic::Response<super::GetArtistResponse>, 761 761 + tonic::Status, 762 762 + > { 763 763 + self.inner 764 764 + .ready() 765 765 + .await 766 766 + .map_err(|e| { 767 767 + tonic::Status::unknown( 768 768 + format!("Service was not ready: {}", e.into()), 769 769 + ) 770 770 + })?; 710 771 let codec = tonic::codec::ProstCodec::default(); 711 711 - let path = 712 712 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtist"); 772 772 + let path = http::uri::PathAndQuery::from_static( 773 773 + "/rockbox.v1alpha1.LibraryService/GetArtist", 774 774 + ); 713 775 let mut req = request.into_request(); 714 714 - req.extensions_mut().insert(GrpcMethod::new( 715 715 - "rockbox.v1alpha1.LibraryService", 716 716 - "GetArtist", 717 717 - )); 776 776 + req.extensions_mut() 777 777 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtist")); 718 778 self.inner.unary(req, path, codec).await 719 779 } 720 780 pub async fn get_track( 721 781 &mut self, 722 782 request: impl tonic::IntoRequest<super::GetTrackRequest>, 723 723 - ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status> { 724 724 - self.inner.ready().await.map_err(|e| { 725 725 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 726 726 - })?; 783 783 + ) -> std::result::Result< 784 784 + tonic::Response<super::GetTrackResponse>, 785 785 + tonic::Status, 786 786 + > { 787 787 + self.inner 788 788 + .ready() 789 789 + .await 790 790 + .map_err(|e| { 791 791 + tonic::Status::unknown( 792 792 + format!("Service was not ready: {}", e.into()), 793 793 + ) 794 794 + })?; 727 795 let codec = tonic::codec::ProstCodec::default(); 728 728 - let path = 729 729 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTrack"); 796 796 + let path = http::uri::PathAndQuery::from_static( 797 797 + "/rockbox.v1alpha1.LibraryService/GetTrack", 798 798 + ); 730 799 let mut req = request.into_request(); 731 731 - req.extensions_mut().insert(GrpcMethod::new( 732 732 - "rockbox.v1alpha1.LibraryService", 733 733 - "GetTrack", 734 734 - )); 800 800 + req.extensions_mut() 801 801 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTrack")); 735 802 self.inner.unary(req, path, codec).await 736 803 } 737 804 pub async fn like_track( 738 805 &mut self, 739 806 request: impl tonic::IntoRequest<super::LikeTrackRequest>, 740 740 - ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status> { 741 741 - self.inner.ready().await.map_err(|e| { 742 742 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 743 743 - })?; 807 807 + ) -> std::result::Result< 808 808 + tonic::Response<super::LikeTrackResponse>, 809 809 + tonic::Status, 810 810 + > { 811 811 + self.inner 812 812 + .ready() 813 813 + .await 814 814 + .map_err(|e| { 815 815 + tonic::Status::unknown( 816 816 + format!("Service was not ready: {}", e.into()), 817 817 + ) 818 818 + })?; 744 819 let codec = tonic::codec::ProstCodec::default(); 745 745 - let path = 746 746 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeTrack"); 820 820 + let path = http::uri::PathAndQuery::from_static( 821 821 + "/rockbox.v1alpha1.LibraryService/LikeTrack", 822 822 + ); 747 823 let mut req = request.into_request(); 748 748 - req.extensions_mut().insert(GrpcMethod::new( 749 749 - "rockbox.v1alpha1.LibraryService", 750 750 - "LikeTrack", 751 751 - )); 824 824 + req.extensions_mut() 825 825 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeTrack")); 752 826 self.inner.unary(req, path, codec).await 753 827 } 754 828 pub async fn unlike_track( 755 829 &mut self, 756 830 request: impl tonic::IntoRequest<super::UnlikeTrackRequest>, 757 757 - ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status> 758 758 - { 759 759 - self.inner.ready().await.map_err(|e| { 760 760 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 761 761 - })?; 831 831 + ) -> std::result::Result< 832 832 + tonic::Response<super::UnlikeTrackResponse>, 833 833 + tonic::Status, 834 834 + > { 835 835 + self.inner 836 836 + .ready() 837 837 + .await 838 838 + .map_err(|e| { 839 839 + tonic::Status::unknown( 840 840 + format!("Service was not ready: {}", e.into()), 841 841 + ) 842 842 + })?; 762 843 let codec = tonic::codec::ProstCodec::default(); 763 844 let path = http::uri::PathAndQuery::from_static( 764 845 "/rockbox.v1alpha1.LibraryService/UnlikeTrack", 765 846 ); 766 847 let mut req = request.into_request(); 767 767 - req.extensions_mut().insert(GrpcMethod::new( 768 768 - "rockbox.v1alpha1.LibraryService", 769 769 - "UnlikeTrack", 770 770 - )); 848 848 + req.extensions_mut() 849 849 + .insert( 850 850 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeTrack"), 851 851 + ); 771 852 self.inner.unary(req, path, codec).await 772 853 } 773 854 pub async fn like_album( 774 855 &mut self, 775 856 request: impl tonic::IntoRequest<super::LikeAlbumRequest>, 776 776 - ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status> { 777 777 - self.inner.ready().await.map_err(|e| { 778 778 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 779 779 - })?; 857 857 + ) -> std::result::Result< 858 858 + tonic::Response<super::LikeAlbumResponse>, 859 859 + tonic::Status, 860 860 + > { 861 861 + self.inner 862 862 + .ready() 863 863 + .await 864 864 + .map_err(|e| { 865 865 + tonic::Status::unknown( 866 866 + format!("Service was not ready: {}", e.into()), 867 867 + ) 868 868 + })?; 780 869 let codec = tonic::codec::ProstCodec::default(); 781 781 - let path = 782 782 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeAlbum"); 870 870 + let path = http::uri::PathAndQuery::from_static( 871 871 + "/rockbox.v1alpha1.LibraryService/LikeAlbum", 872 872 + ); 783 873 let mut req = request.into_request(); 784 784 - req.extensions_mut().insert(GrpcMethod::new( 785 785 - "rockbox.v1alpha1.LibraryService", 786 786 - "LikeAlbum", 787 787 - )); 874 874 + req.extensions_mut() 875 875 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeAlbum")); 788 876 self.inner.unary(req, path, codec).await 789 877 } 790 878 pub async fn unlike_album( 791 879 &mut self, 792 880 request: impl tonic::IntoRequest<super::UnlikeAlbumRequest>, 793 793 - ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status> 794 794 - { 795 795 - self.inner.ready().await.map_err(|e| { 796 796 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 797 797 - })?; 881 881 + ) -> std::result::Result< 882 882 + tonic::Response<super::UnlikeAlbumResponse>, 883 883 + tonic::Status, 884 884 + > { 885 885 + self.inner 886 886 + .ready() 887 887 + .await 888 888 + .map_err(|e| { 889 889 + tonic::Status::unknown( 890 890 + format!("Service was not ready: {}", e.into()), 891 891 + ) 892 892 + })?; 798 893 let codec = tonic::codec::ProstCodec::default(); 799 894 let path = http::uri::PathAndQuery::from_static( 800 895 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum", 801 896 ); 802 897 let mut req = request.into_request(); 803 803 - req.extensions_mut().insert(GrpcMethod::new( 804 804 - "rockbox.v1alpha1.LibraryService", 805 805 - "UnlikeAlbum", 806 806 - )); 898 898 + req.extensions_mut() 899 899 + .insert( 900 900 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeAlbum"), 901 901 + ); 807 902 self.inner.unary(req, path, codec).await 808 903 } 809 904 pub async fn get_liked_tracks( 810 905 &mut self, 811 906 request: impl tonic::IntoRequest<super::GetLikedTracksRequest>, 812 812 - ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status> 813 813 - { 814 814 - self.inner.ready().await.map_err(|e| { 815 815 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 816 816 - })?; 907 907 + ) -> std::result::Result< 908 908 + tonic::Response<super::GetLikedTracksResponse>, 909 909 + tonic::Status, 910 910 + > { 911 911 + self.inner 912 912 + .ready() 913 913 + .await 914 914 + .map_err(|e| { 915 915 + tonic::Status::unknown( 916 916 + format!("Service was not ready: {}", e.into()), 917 917 + ) 918 918 + })?; 817 919 let codec = tonic::codec::ProstCodec::default(); 818 920 let path = http::uri::PathAndQuery::from_static( 819 921 "/rockbox.v1alpha1.LibraryService/GetLikedTracks", 820 922 ); 821 923 let mut req = request.into_request(); 822 822 - req.extensions_mut().insert(GrpcMethod::new( 823 823 - "rockbox.v1alpha1.LibraryService", 824 824 - "GetLikedTracks", 825 825 - )); 924 924 + req.extensions_mut() 925 925 + .insert( 926 926 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedTracks"), 927 927 + ); 826 928 self.inner.unary(req, path, codec).await 827 929 } 828 930 pub async fn get_liked_albums( 829 931 &mut self, 830 932 request: impl tonic::IntoRequest<super::GetLikedAlbumsRequest>, 831 831 - ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status> 832 832 - { 833 833 - self.inner.ready().await.map_err(|e| { 834 834 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 835 835 - })?; 933 933 + ) -> std::result::Result< 934 934 + tonic::Response<super::GetLikedAlbumsResponse>, 935 935 + tonic::Status, 936 936 + > { 937 937 + self.inner 938 938 + .ready() 939 939 + .await 940 940 + .map_err(|e| { 941 941 + tonic::Status::unknown( 942 942 + format!("Service was not ready: {}", e.into()), 943 943 + ) 944 944 + })?; 836 945 let codec = tonic::codec::ProstCodec::default(); 837 946 let path = http::uri::PathAndQuery::from_static( 838 947 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums", 839 948 ); 840 949 let mut req = request.into_request(); 841 841 - req.extensions_mut().insert(GrpcMethod::new( 842 842 - "rockbox.v1alpha1.LibraryService", 843 843 - "GetLikedAlbums", 844 844 - )); 950 950 + req.extensions_mut() 951 951 + .insert( 952 952 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedAlbums"), 953 953 + ); 845 954 self.inner.unary(req, path, codec).await 846 955 } 847 956 pub async fn scan_library( 848 957 &mut self, 849 958 request: impl tonic::IntoRequest<super::ScanLibraryRequest>, 850 850 - ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status> 851 851 - { 852 852 - self.inner.ready().await.map_err(|e| { 853 853 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 854 854 - })?; 959 959 + ) -> std::result::Result< 960 960 + tonic::Response<super::ScanLibraryResponse>, 961 961 + tonic::Status, 962 962 + > { 963 963 + self.inner 964 964 + .ready() 965 965 + .await 966 966 + .map_err(|e| { 967 967 + tonic::Status::unknown( 968 968 + format!("Service was not ready: {}", e.into()), 969 969 + ) 970 970 + })?; 855 971 let codec = tonic::codec::ProstCodec::default(); 856 972 let path = http::uri::PathAndQuery::from_static( 857 973 "/rockbox.v1alpha1.LibraryService/ScanLibrary", 858 974 ); 859 975 let mut req = request.into_request(); 860 860 - req.extensions_mut().insert(GrpcMethod::new( 861 861 - "rockbox.v1alpha1.LibraryService", 862 862 - "ScanLibrary", 863 863 - )); 976 976 + req.extensions_mut() 977 977 + .insert( 978 978 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "ScanLibrary"), 979 979 + ); 864 980 self.inner.unary(req, path, codec).await 865 981 } 866 982 pub async fn stream_library( ··· 870 986 tonic::Response<tonic::codec::Streaming<super::StreamLibraryResponse>>, 871 987 tonic::Status, 872 988 > { 873 873 - self.inner.ready().await.map_err(|e| { 874 874 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 875 875 - })?; 989 989 + self.inner 990 990 + .ready() 991 991 + .await 992 992 + .map_err(|e| { 993 993 + tonic::Status::unknown( 994 994 + format!("Service was not ready: {}", e.into()), 995 995 + ) 996 996 + })?; 876 997 let codec = tonic::codec::ProstCodec::default(); 877 998 let path = http::uri::PathAndQuery::from_static( 878 999 "/rockbox.v1alpha1.LibraryService/StreamLibrary", 879 1000 ); 880 1001 let mut req = request.into_request(); 881 881 - req.extensions_mut().insert(GrpcMethod::new( 882 882 - "rockbox.v1alpha1.LibraryService", 883 883 - "StreamLibrary", 884 884 - )); 1002 1002 + req.extensions_mut() 1003 1003 + .insert( 1004 1004 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "StreamLibrary"), 1005 1005 + ); 885 1006 self.inner.server_streaming(req, path, codec).await 886 1007 } 887 1008 pub async fn search( 888 1009 &mut self, 889 1010 request: impl tonic::IntoRequest<super::SearchRequest>, 890 1011 ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> { 891 891 - self.inner.ready().await.map_err(|e| { 892 892 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 893 893 - })?; 1012 1012 + self.inner 1013 1013 + .ready() 1014 1014 + .await 1015 1015 + .map_err(|e| { 1016 1016 + tonic::Status::unknown( 1017 1017 + format!("Service was not ready: {}", e.into()), 1018 1018 + ) 1019 1019 + })?; 894 1020 let codec = tonic::codec::ProstCodec::default(); 895 895 - let path = 896 896 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/Search"); 1021 1021 + let path = http::uri::PathAndQuery::from_static( 1022 1022 + "/rockbox.v1alpha1.LibraryService/Search", 1023 1023 + ); 897 1024 let mut req = request.into_request(); 898 1025 req.extensions_mut() 899 1026 .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "Search")); ··· 908 1035 dead_code, 909 1036 missing_docs, 910 1037 clippy::wildcard_imports, 911 911 - clippy::let_unit_value 1038 1038 + clippy::let_unit_value, 912 1039 )] 913 1040 use tonic::codegen::*; 914 1041 /// Generated trait containing gRPC methods that should be implemented for use with LibraryServiceServer. ··· 917 1044 async fn get_albums( 918 1045 &self, 919 1046 request: tonic::Request<super::GetAlbumsRequest>, 920 920 - ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status>; 1047 1047 + ) -> std::result::Result< 1048 1048 + tonic::Response<super::GetAlbumsResponse>, 1049 1049 + tonic::Status, 1050 1050 + >; 921 1051 async fn get_artists( 922 1052 &self, 923 1053 request: tonic::Request<super::GetArtistsRequest>, 924 924 - ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status>; 1054 1054 + ) -> std::result::Result< 1055 1055 + tonic::Response<super::GetArtistsResponse>, 1056 1056 + tonic::Status, 1057 1057 + >; 925 1058 async fn get_tracks( 926 1059 &self, 927 1060 request: tonic::Request<super::GetTracksRequest>, 928 928 - ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status>; 1061 1061 + ) -> std::result::Result< 1062 1062 + tonic::Response<super::GetTracksResponse>, 1063 1063 + tonic::Status, 1064 1064 + >; 929 1065 async fn get_album( 930 1066 &self, 931 1067 request: tonic::Request<super::GetAlbumRequest>, 932 932 - ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status>; 1068 1068 + ) -> std::result::Result< 1069 1069 + tonic::Response<super::GetAlbumResponse>, 1070 1070 + tonic::Status, 1071 1071 + >; 933 1072 async fn get_artist( 934 1073 &self, 935 1074 request: tonic::Request<super::GetArtistRequest>, 936 936 - ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status>; 1075 1075 + ) -> std::result::Result< 1076 1076 + tonic::Response<super::GetArtistResponse>, 1077 1077 + tonic::Status, 1078 1078 + >; 937 1079 async fn get_track( 938 1080 &self, 939 1081 request: tonic::Request<super::GetTrackRequest>, 940 940 - ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status>; 1082 1082 + ) -> std::result::Result< 1083 1083 + tonic::Response<super::GetTrackResponse>, 1084 1084 + tonic::Status, 1085 1085 + >; 941 1086 async fn like_track( 942 1087 &self, 943 1088 request: tonic::Request<super::LikeTrackRequest>, 944 944 - ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status>; 1089 1089 + ) -> std::result::Result< 1090 1090 + tonic::Response<super::LikeTrackResponse>, 1091 1091 + tonic::Status, 1092 1092 + >; 945 1093 async fn unlike_track( 946 1094 &self, 947 1095 request: tonic::Request<super::UnlikeTrackRequest>, 948 948 - ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status>; 1096 1096 + ) -> std::result::Result< 1097 1097 + tonic::Response<super::UnlikeTrackResponse>, 1098 1098 + tonic::Status, 1099 1099 + >; 949 1100 async fn like_album( 950 1101 &self, 951 1102 request: tonic::Request<super::LikeAlbumRequest>, 952 952 - ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status>; 1103 1103 + ) -> std::result::Result< 1104 1104 + tonic::Response<super::LikeAlbumResponse>, 1105 1105 + tonic::Status, 1106 1106 + >; 953 1107 async fn unlike_album( 954 1108 &self, 955 1109 request: tonic::Request<super::UnlikeAlbumRequest>, 956 956 - ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status>; 1110 1110 + ) -> std::result::Result< 1111 1111 + tonic::Response<super::UnlikeAlbumResponse>, 1112 1112 + tonic::Status, 1113 1113 + >; 957 1114 async fn get_liked_tracks( 958 1115 &self, 959 1116 request: tonic::Request<super::GetLikedTracksRequest>, 960 960 - ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status>; 1117 1117 + ) -> std::result::Result< 1118 1118 + tonic::Response<super::GetLikedTracksResponse>, 1119 1119 + tonic::Status, 1120 1120 + >; 961 1121 async fn get_liked_albums( 962 1122 &self, 963 1123 request: tonic::Request<super::GetLikedAlbumsRequest>, 964 964 - ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status>; 1124 1124 + ) -> std::result::Result< 1125 1125 + tonic::Response<super::GetLikedAlbumsResponse>, 1126 1126 + tonic::Status, 1127 1127 + >; 965 1128 async fn scan_library( 966 1129 &self, 967 1130 request: tonic::Request<super::ScanLibraryRequest>, 968 968 - ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>; 1131 1131 + ) -> std::result::Result< 1132 1132 + tonic::Response<super::ScanLibraryResponse>, 1133 1133 + tonic::Status, 1134 1134 + >; 969 1135 /// Server streaming response type for the StreamLibrary method. 970 1136 type StreamLibraryStream: tonic::codegen::tokio_stream::Stream< 971 1137 Item = std::result::Result<super::StreamLibraryResponse, tonic::Status>, 972 972 - > + std::marker::Send 1138 1138 + > 1139 1139 + + std::marker::Send 973 1140 + 'static; 974 1141 async fn stream_library( 975 1142 &self, 976 1143 request: tonic::Request<super::StreamLibraryRequest>, 977 977 - ) -> std::result::Result<tonic::Response<Self::StreamLibraryStream>, tonic::Status>; 1144 1144 + ) -> std::result::Result< 1145 1145 + tonic::Response<Self::StreamLibraryStream>, 1146 1146 + tonic::Status, 1147 1147 + >; 978 1148 async fn search( 979 1149 &self, 980 1150 request: tonic::Request<super::SearchRequest>, ··· 1001 1171 max_encoding_message_size: None, 1002 1172 } 1003 1173 } 1004 1004 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1174 1174 + pub fn with_interceptor<F>( 1175 1175 + inner: T, 1176 1176 + interceptor: F, 1177 1177 + ) -> InterceptedService<Self, F> 1005 1178 where 1006 1179 F: tonic::service::Interceptor, 1007 1180 { ··· 1056 1229 "/rockbox.v1alpha1.LibraryService/GetAlbums" => { 1057 1230 #[allow(non_camel_case_types)] 1058 1231 struct GetAlbumsSvc<T: LibraryService>(pub Arc<T>); 1059 1059 - impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumsRequest> for GetAlbumsSvc<T> { 1232 1232 + impl< 1233 1233 + T: LibraryService, 1234 1234 + > tonic::server::UnaryService<super::GetAlbumsRequest> 1235 1235 + for GetAlbumsSvc<T> { 1060 1236 type Response = super::GetAlbumsResponse; 1061 1061 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1237 1237 + type Future = BoxFuture< 1238 1238 + tonic::Response<Self::Response>, 1239 1239 + tonic::Status, 1240 1240 + >; 1062 1241 fn call( 1063 1242 &mut self, 1064 1243 request: tonic::Request<super::GetAlbumsRequest>, ··· 1095 1274 "/rockbox.v1alpha1.LibraryService/GetArtists" => { 1096 1275 #[allow(non_camel_case_types)] 1097 1276 struct GetArtistsSvc<T: LibraryService>(pub Arc<T>); 1098 1098 - impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistsRequest> for GetArtistsSvc<T> { 1277 1277 + impl< 1278 1278 + T: LibraryService, 1279 1279 + > tonic::server::UnaryService<super::GetArtistsRequest> 1280 1280 + for GetArtistsSvc<T> { 1099 1281 type Response = super::GetArtistsResponse; 1100 1100 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1282 1282 + type Future = BoxFuture< 1283 1283 + tonic::Response<Self::Response>, 1284 1284 + tonic::Status, 1285 1285 + >; 1101 1286 fn call( 1102 1287 &mut self, 1103 1288 request: tonic::Request<super::GetArtistsRequest>, ··· 1134 1319 "/rockbox.v1alpha1.LibraryService/GetTracks" => { 1135 1320 #[allow(non_camel_case_types)] 1136 1321 struct GetTracksSvc<T: LibraryService>(pub Arc<T>); 1137 1137 - impl<T: LibraryService> tonic::server::UnaryService<super::GetTracksRequest> for GetTracksSvc<T> { 1322 1322 + impl< 1323 1323 + T: LibraryService, 1324 1324 + > tonic::server::UnaryService<super::GetTracksRequest> 1325 1325 + for GetTracksSvc<T> { 1138 1326 type Response = super::GetTracksResponse; 1139 1139 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1327 1327 + type Future = BoxFuture< 1328 1328 + tonic::Response<Self::Response>, 1329 1329 + tonic::Status, 1330 1330 + >; 1140 1331 fn call( 1141 1332 &mut self, 1142 1333 request: tonic::Request<super::GetTracksRequest>, ··· 1173 1364 "/rockbox.v1alpha1.LibraryService/GetAlbum" => { 1174 1365 #[allow(non_camel_case_types)] 1175 1366 struct GetAlbumSvc<T: LibraryService>(pub Arc<T>); 1176 1176 - impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumRequest> for GetAlbumSvc<T> { 1367 1367 + impl< 1368 1368 + T: LibraryService, 1369 1369 + > tonic::server::UnaryService<super::GetAlbumRequest> 1370 1370 + for GetAlbumSvc<T> { 1177 1371 type Response = super::GetAlbumResponse; 1178 1178 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1372 1372 + type Future = BoxFuture< 1373 1373 + tonic::Response<Self::Response>, 1374 1374 + tonic::Status, 1375 1375 + >; 1179 1376 fn call( 1180 1377 &mut self, 1181 1378 request: tonic::Request<super::GetAlbumRequest>, ··· 1212 1409 "/rockbox.v1alpha1.LibraryService/GetArtist" => { 1213 1410 #[allow(non_camel_case_types)] 1214 1411 struct GetArtistSvc<T: LibraryService>(pub Arc<T>); 1215 1215 - impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistRequest> for GetArtistSvc<T> { 1412 1412 + impl< 1413 1413 + T: LibraryService, 1414 1414 + > tonic::server::UnaryService<super::GetArtistRequest> 1415 1415 + for GetArtistSvc<T> { 1216 1416 type Response = super::GetArtistResponse; 1217 1217 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1417 1417 + type Future = BoxFuture< 1418 1418 + tonic::Response<Self::Response>, 1419 1419 + tonic::Status, 1420 1420 + >; 1218 1421 fn call( 1219 1422 &mut self, 1220 1423 request: tonic::Request<super::GetArtistRequest>, ··· 1251 1454 "/rockbox.v1alpha1.LibraryService/GetTrack" => { 1252 1455 #[allow(non_camel_case_types)] 1253 1456 struct GetTrackSvc<T: LibraryService>(pub Arc<T>); 1254 1254 - impl<T: LibraryService> tonic::server::UnaryService<super::GetTrackRequest> for GetTrackSvc<T> { 1457 1457 + impl< 1458 1458 + T: LibraryService, 1459 1459 + > tonic::server::UnaryService<super::GetTrackRequest> 1460 1460 + for GetTrackSvc<T> { 1255 1461 type Response = super::GetTrackResponse; 1256 1256 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1462 1462 + type Future = BoxFuture< 1463 1463 + tonic::Response<Self::Response>, 1464 1464 + tonic::Status, 1465 1465 + >; 1257 1466 fn call( 1258 1467 &mut self, 1259 1468 request: tonic::Request<super::GetTrackRequest>, ··· 1290 1499 "/rockbox.v1alpha1.LibraryService/LikeTrack" => { 1291 1500 #[allow(non_camel_case_types)] 1292 1501 struct LikeTrackSvc<T: LibraryService>(pub Arc<T>); 1293 1293 - impl<T: LibraryService> tonic::server::UnaryService<super::LikeTrackRequest> for LikeTrackSvc<T> { 1502 1502 + impl< 1503 1503 + T: LibraryService, 1504 1504 + > tonic::server::UnaryService<super::LikeTrackRequest> 1505 1505 + for LikeTrackSvc<T> { 1294 1506 type Response = super::LikeTrackResponse; 1295 1295 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1507 1507 + type Future = BoxFuture< 1508 1508 + tonic::Response<Self::Response>, 1509 1509 + tonic::Status, 1510 1510 + >; 1296 1511 fn call( 1297 1512 &mut self, 1298 1513 request: tonic::Request<super::LikeTrackRequest>, ··· 1329 1544 "/rockbox.v1alpha1.LibraryService/UnlikeTrack" => { 1330 1545 #[allow(non_camel_case_types)] 1331 1546 struct UnlikeTrackSvc<T: LibraryService>(pub Arc<T>); 1332 1332 - impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeTrackRequest> 1333 1333 - for UnlikeTrackSvc<T> 1334 1334 - { 1547 1547 + impl< 1548 1548 + T: LibraryService, 1549 1549 + > tonic::server::UnaryService<super::UnlikeTrackRequest> 1550 1550 + for UnlikeTrackSvc<T> { 1335 1551 type Response = super::UnlikeTrackResponse; 1336 1336 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1552 1552 + type Future = BoxFuture< 1553 1553 + tonic::Response<Self::Response>, 1554 1554 + tonic::Status, 1555 1555 + >; 1337 1556 fn call( 1338 1557 &mut self, 1339 1558 request: tonic::Request<super::UnlikeTrackRequest>, ··· 1370 1589 "/rockbox.v1alpha1.LibraryService/LikeAlbum" => { 1371 1590 #[allow(non_camel_case_types)] 1372 1591 struct LikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1373 1373 - impl<T: LibraryService> tonic::server::UnaryService<super::LikeAlbumRequest> for LikeAlbumSvc<T> { 1592 1592 + impl< 1593 1593 + T: LibraryService, 1594 1594 + > tonic::server::UnaryService<super::LikeAlbumRequest> 1595 1595 + for LikeAlbumSvc<T> { 1374 1596 type Response = super::LikeAlbumResponse; 1375 1375 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1597 1597 + type Future = BoxFuture< 1598 1598 + tonic::Response<Self::Response>, 1599 1599 + tonic::Status, 1600 1600 + >; 1376 1601 fn call( 1377 1602 &mut self, 1378 1603 request: tonic::Request<super::LikeAlbumRequest>, ··· 1409 1634 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum" => { 1410 1635 #[allow(non_camel_case_types)] 1411 1636 struct UnlikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1412 1412 - impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeAlbumRequest> 1413 1413 - for UnlikeAlbumSvc<T> 1414 1414 - { 1637 1637 + impl< 1638 1638 + T: LibraryService, 1639 1639 + > tonic::server::UnaryService<super::UnlikeAlbumRequest> 1640 1640 + for UnlikeAlbumSvc<T> { 1415 1641 type Response = super::UnlikeAlbumResponse; 1416 1416 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1642 1642 + type Future = BoxFuture< 1643 1643 + tonic::Response<Self::Response>, 1644 1644 + tonic::Status, 1645 1645 + >; 1417 1646 fn call( 1418 1647 &mut self, 1419 1648 request: tonic::Request<super::UnlikeAlbumRequest>, ··· 1450 1679 "/rockbox.v1alpha1.LibraryService/GetLikedTracks" => { 1451 1680 #[allow(non_camel_case_types)] 1452 1681 struct GetLikedTracksSvc<T: LibraryService>(pub Arc<T>); 1453 1453 - impl<T: LibraryService> 1454 1454 - tonic::server::UnaryService<super::GetLikedTracksRequest> 1455 1455 - for GetLikedTracksSvc<T> 1456 1456 - { 1682 1682 + impl< 1683 1683 + T: LibraryService, 1684 1684 + > tonic::server::UnaryService<super::GetLikedTracksRequest> 1685 1685 + for GetLikedTracksSvc<T> { 1457 1686 type Response = super::GetLikedTracksResponse; 1458 1458 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1687 1687 + type Future = BoxFuture< 1688 1688 + tonic::Response<Self::Response>, 1689 1689 + tonic::Status, 1690 1690 + >; 1459 1691 fn call( 1460 1692 &mut self, 1461 1693 request: tonic::Request<super::GetLikedTracksRequest>, 1462 1694 ) -> Self::Future { 1463 1695 let inner = Arc::clone(&self.0); 1464 1696 let fut = async move { 1465 1465 - <T as LibraryService>::get_liked_tracks(&inner, request).await 1697 1697 + <T as LibraryService>::get_liked_tracks(&inner, request) 1698 1698 + .await 1466 1699 }; 1467 1700 Box::pin(fut) 1468 1701 } ··· 1492 1725 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums" => { 1493 1726 #[allow(non_camel_case_types)] 1494 1727 struct GetLikedAlbumsSvc<T: LibraryService>(pub Arc<T>); 1495 1495 - impl<T: LibraryService> 1496 1496 - tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1497 1497 - for GetLikedAlbumsSvc<T> 1498 1498 - { 1728 1728 + impl< 1729 1729 + T: LibraryService, 1730 1730 + > tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1731 1731 + for GetLikedAlbumsSvc<T> { 1499 1732 type Response = super::GetLikedAlbumsResponse; 1500 1500 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1733 1733 + type Future = BoxFuture< 1734 1734 + tonic::Response<Self::Response>, 1735 1735 + tonic::Status, 1736 1736 + >; 1501 1737 fn call( 1502 1738 &mut self, 1503 1739 request: tonic::Request<super::GetLikedAlbumsRequest>, 1504 1740 ) -> Self::Future { 1505 1741 let inner = Arc::clone(&self.0); 1506 1742 let fut = async move { 1507 1507 - <T as LibraryService>::get_liked_albums(&inner, request).await 1743 1743 + <T as LibraryService>::get_liked_albums(&inner, request) 1744 1744 + .await 1508 1745 }; 1509 1746 Box::pin(fut) 1510 1747 } ··· 1534 1771 "/rockbox.v1alpha1.LibraryService/ScanLibrary" => { 1535 1772 #[allow(non_camel_case_types)] 1536 1773 struct ScanLibrarySvc<T: LibraryService>(pub Arc<T>); 1537 1537 - impl<T: LibraryService> tonic::server::UnaryService<super::ScanLibraryRequest> 1538 1538 - for ScanLibrarySvc<T> 1539 1539 - { 1774 1774 + impl< 1775 1775 + T: LibraryService, 1776 1776 + > tonic::server::UnaryService<super::ScanLibraryRequest> 1777 1777 + for ScanLibrarySvc<T> { 1540 1778 type Response = super::ScanLibraryResponse; 1541 1541 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1779 1779 + type Future = BoxFuture< 1780 1780 + tonic::Response<Self::Response>, 1781 1781 + tonic::Status, 1782 1782 + >; 1542 1783 fn call( 1543 1784 &mut self, 1544 1785 request: tonic::Request<super::ScanLibraryRequest>, ··· 1575 1816 "/rockbox.v1alpha1.LibraryService/StreamLibrary" => { 1576 1817 #[allow(non_camel_case_types)] 1577 1818 struct StreamLibrarySvc<T: LibraryService>(pub Arc<T>); 1578 1578 - impl<T: LibraryService> 1579 1579 - tonic::server::ServerStreamingService<super::StreamLibraryRequest> 1580 1580 - for StreamLibrarySvc<T> 1581 1581 - { 1819 1819 + impl< 1820 1820 + T: LibraryService, 1821 1821 + > tonic::server::ServerStreamingService<super::StreamLibraryRequest> 1822 1822 + for StreamLibrarySvc<T> { 1582 1823 type Response = super::StreamLibraryResponse; 1583 1824 type ResponseStream = T::StreamLibraryStream; 1584 1584 - type Future = 1585 1585 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 1825 1825 + type Future = BoxFuture< 1826 1826 + tonic::Response<Self::ResponseStream>, 1827 1827 + tonic::Status, 1828 1828 + >; 1586 1829 fn call( 1587 1830 &mut self, 1588 1831 request: tonic::Request<super::StreamLibraryRequest>, ··· 1619 1862 "/rockbox.v1alpha1.LibraryService/Search" => { 1620 1863 #[allow(non_camel_case_types)] 1621 1864 struct SearchSvc<T: LibraryService>(pub Arc<T>); 1622 1622 - impl<T: LibraryService> tonic::server::UnaryService<super::SearchRequest> for SearchSvc<T> { 1865 1865 + impl< 1866 1866 + T: LibraryService, 1867 1867 + > tonic::server::UnaryService<super::SearchRequest> 1868 1868 + for SearchSvc<T> { 1623 1869 type Response = super::SearchResponse; 1624 1624 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1870 1870 + type Future = BoxFuture< 1871 1871 + tonic::Response<Self::Response>, 1872 1872 + tonic::Status, 1873 1873 + >; 1625 1874 fn call( 1626 1875 &mut self, 1627 1876 request: tonic::Request<super::SearchRequest>, 1628 1877 ) -> Self::Future { 1629 1878 let inner = Arc::clone(&self.0); 1630 1630 - let fut = 1631 1631 - async move { <T as LibraryService>::search(&inner, request).await }; 1879 1879 + let fut = async move { 1880 1880 + <T as LibraryService>::search(&inner, request).await 1881 1881 + }; 1632 1882 Box::pin(fut) 1633 1883 } 1634 1884 } ··· 1654 1904 }; 1655 1905 Box::pin(fut) 1656 1906 } 1657 1657 - _ => Box::pin(async move { 1658 1658 - let mut response = http::Response::new(empty_body()); 1659 1659 - let headers = response.headers_mut(); 1660 1660 - headers.insert( 1661 1661 - tonic::Status::GRPC_STATUS, 1662 1662 - (tonic::Code::Unimplemented as i32).into(), 1663 1663 - ); 1664 1664 - headers.insert( 1665 1665 - http::header::CONTENT_TYPE, 1666 1666 - tonic::metadata::GRPC_CONTENT_TYPE, 1667 1667 - ); 1668 1668 - Ok(response) 1669 1669 - }), 1907 1907 + _ => { 1908 1908 + Box::pin(async move { 1909 1909 + let mut response = http::Response::new(empty_body()); 1910 1910 + let headers = response.headers_mut(); 1911 1911 + headers 1912 1912 + .insert( 1913 1913 + tonic::Status::GRPC_STATUS, 1914 1914 + (tonic::Code::Unimplemented as i32).into(), 1915 1915 + ); 1916 1916 + headers 1917 1917 + .insert( 1918 1918 + http::header::CONTENT_TYPE, 1919 1919 + tonic::metadata::GRPC_CONTENT_TYPE, 1920 1920 + ); 1921 1921 + Ok(response) 1922 1922 + }) 1923 1923 + } 1670 1924 } 1671 1925 } 1672 1926 } ··· 1695 1949 dead_code, 1696 1950 missing_docs, 1697 1951 clippy::wildcard_imports, 1698 1698 - clippy::let_unit_value 1952 1952 + clippy::let_unit_value, 1699 1953 )] 1700 1700 - use tonic::codegen::http::Uri; 1701 1954 use tonic::codegen::*; 1955 1955 + use tonic::codegen::http::Uri; 1702 1956 #[derive(Debug, Clone)] 1703 1957 pub struct MetadataServiceClient<T> { 1704 1958 inner: tonic::client::Grpc<T>, ··· 1742 1996 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 1743 1997 >, 1744 1998 >, 1745 1745 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 1746 1746 - Into<StdError> + std::marker::Send + std::marker::Sync, 1999 1999 + <T as tonic::codegen::Service< 2000 2000 + http::Request<tonic::body::BoxBody>, 2001 2001 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 1747 2002 { 1748 2003 MetadataServiceClient::new(InterceptedService::new(inner, interceptor)) 1749 2004 } ··· 1787 2042 dead_code, 1788 2043 missing_docs, 1789 2044 clippy::wildcard_imports, 1790 1790 - clippy::let_unit_value 2045 2045 + clippy::let_unit_value, 1791 2046 )] 1792 2047 use tonic::codegen::*; 1793 2048 /// Generated trait containing gRPC methods that should be implemented for use with MetadataServiceServer. ··· 1814 2069 max_encoding_message_size: None, 1815 2070 } 1816 2071 } 1817 1817 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 2072 2072 + pub fn with_interceptor<F>( 2073 2073 + inner: T, 2074 2074 + interceptor: F, 2075 2075 + ) -> InterceptedService<Self, F> 1818 2076 where 1819 2077 F: tonic::service::Interceptor, 1820 2078 { ··· 1866 2124 } 1867 2125 fn call(&mut self, req: http::Request<B>) -> Self::Future { 1868 2126 match req.uri().path() { 1869 1869 - _ => Box::pin(async move { 1870 1870 - let mut response = http::Response::new(empty_body()); 1871 1871 - let headers = response.headers_mut(); 1872 1872 - headers.insert( 1873 1873 - tonic::Status::GRPC_STATUS, 1874 1874 - (tonic::Code::Unimplemented as i32).into(), 1875 1875 - ); 1876 1876 - headers.insert( 1877 1877 - http::header::CONTENT_TYPE, 1878 1878 - tonic::metadata::GRPC_CONTENT_TYPE, 1879 1879 - ); 1880 1880 - Ok(response) 1881 1881 - }), 2127 2127 + _ => { 2128 2128 + Box::pin(async move { 2129 2129 + let mut response = http::Response::new(empty_body()); 2130 2130 + let headers = response.headers_mut(); 2131 2131 + headers 2132 2132 + .insert( 2133 2133 + tonic::Status::GRPC_STATUS, 2134 2134 + (tonic::Code::Unimplemented as i32).into(), 2135 2135 + ); 2136 2136 + headers 2137 2137 + .insert( 2138 2138 + http::header::CONTENT_TYPE, 2139 2139 + tonic::metadata::GRPC_CONTENT_TYPE, 2140 2140 + ); 2141 2141 + Ok(response) 2142 2142 + }) 2143 2143 + } 1882 2144 } 1883 2145 } 1884 2146 } ··· 2162 2424 dead_code, 2163 2425 missing_docs, 2164 2426 clippy::wildcard_imports, 2165 2165 - clippy::let_unit_value 2427 2427 + clippy::let_unit_value, 2166 2428 )] 2167 2167 - use tonic::codegen::http::Uri; 2168 2429 use tonic::codegen::*; 2430 2430 + use tonic::codegen::http::Uri; 2169 2431 #[derive(Debug, Clone)] 2170 2432 pub struct PlaybackServiceClient<T> { 2171 2433 inner: tonic::client::Grpc<T>, ··· 2209 2471 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 2210 2472 >, 2211 2473 >, 2212 2212 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 2213 2213 - Into<StdError> + std::marker::Send + std::marker::Sync, 2474 2474 + <T as tonic::codegen::Service< 2475 2475 + http::Request<tonic::body::BoxBody>, 2476 2476 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 2214 2477 { 2215 2478 PlaybackServiceClient::new(InterceptedService::new(inner, interceptor)) 2216 2479 } ··· 2249 2512 &mut self, 2250 2513 request: impl tonic::IntoRequest<super::PlayRequest>, 2251 2514 ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> { 2252 2252 - self.inner.ready().await.map_err(|e| { 2253 2253 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2254 2254 - })?; 2515 2515 + self.inner 2516 2516 + .ready() 2517 2517 + .await 2518 2518 + .map_err(|e| { 2519 2519 + tonic::Status::unknown( 2520 2520 + format!("Service was not ready: {}", e.into()), 2521 2521 + ) 2522 2522 + })?; 2255 2523 let codec = tonic::codec::ProstCodec::default(); 2256 2256 - let path = 2257 2257 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Play"); 2524 2524 + let path = http::uri::PathAndQuery::from_static( 2525 2525 + "/rockbox.v1alpha1.PlaybackService/Play", 2526 2526 + ); 2258 2527 let mut req = request.into_request(); 2259 2528 req.extensions_mut() 2260 2529 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Play")); ··· 2264 2533 &mut self, 2265 2534 request: impl tonic::IntoRequest<super::PauseRequest>, 2266 2535 ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> { 2267 2267 - self.inner.ready().await.map_err(|e| { 2268 2268 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2269 2269 - })?; 2536 2536 + self.inner 2537 2537 + .ready() 2538 2538 + .await 2539 2539 + .map_err(|e| { 2540 2540 + tonic::Status::unknown( 2541 2541 + format!("Service was not ready: {}", e.into()), 2542 2542 + ) 2543 2543 + })?; 2270 2544 let codec = tonic::codec::ProstCodec::default(); 2271 2271 - let path = 2272 2272 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Pause"); 2545 2545 + let path = http::uri::PathAndQuery::from_static( 2546 2546 + "/rockbox.v1alpha1.PlaybackService/Pause", 2547 2547 + ); 2273 2548 let mut req = request.into_request(); 2274 2549 req.extensions_mut() 2275 2550 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Pause")); ··· 2278 2553 pub async fn play_or_pause( 2279 2554 &mut self, 2280 2555 request: impl tonic::IntoRequest<super::PlayOrPauseRequest>, 2281 2281 - ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status> 2282 2282 - { 2283 2283 - self.inner.ready().await.map_err(|e| { 2284 2284 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2285 2285 - })?; 2556 2556 + ) -> std::result::Result< 2557 2557 + tonic::Response<super::PlayOrPauseResponse>, 2558 2558 + tonic::Status, 2559 2559 + > { 2560 2560 + self.inner 2561 2561 + .ready() 2562 2562 + .await 2563 2563 + .map_err(|e| { 2564 2564 + tonic::Status::unknown( 2565 2565 + format!("Service was not ready: {}", e.into()), 2566 2566 + ) 2567 2567 + })?; 2286 2568 let codec = tonic::codec::ProstCodec::default(); 2287 2569 let path = http::uri::PathAndQuery::from_static( 2288 2570 "/rockbox.v1alpha1.PlaybackService/PlayOrPause", 2289 2571 ); 2290 2572 let mut req = request.into_request(); 2291 2291 - req.extensions_mut().insert(GrpcMethod::new( 2292 2292 - "rockbox.v1alpha1.PlaybackService", 2293 2293 - "PlayOrPause", 2294 2294 - )); 2573 2573 + req.extensions_mut() 2574 2574 + .insert( 2575 2575 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayOrPause"), 2576 2576 + ); 2295 2577 self.inner.unary(req, path, codec).await 2296 2578 } 2297 2579 pub async fn resume( 2298 2580 &mut self, 2299 2581 request: impl tonic::IntoRequest<super::ResumeRequest>, 2300 2582 ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> { 2301 2301 - self.inner.ready().await.map_err(|e| { 2302 2302 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2303 2303 - })?; 2583 2583 + self.inner 2584 2584 + .ready() 2585 2585 + .await 2586 2586 + .map_err(|e| { 2587 2587 + tonic::Status::unknown( 2588 2588 + format!("Service was not ready: {}", e.into()), 2589 2589 + ) 2590 2590 + })?; 2304 2591 let codec = tonic::codec::ProstCodec::default(); 2305 2305 - let path = 2306 2306 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Resume"); 2592 2592 + let path = http::uri::PathAndQuery::from_static( 2593 2593 + "/rockbox.v1alpha1.PlaybackService/Resume", 2594 2594 + ); 2307 2595 let mut req = request.into_request(); 2308 2308 - req.extensions_mut().insert(GrpcMethod::new( 2309 2309 - "rockbox.v1alpha1.PlaybackService", 2310 2310 - "Resume", 2311 2311 - )); 2596 2596 + req.extensions_mut() 2597 2597 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Resume")); 2312 2598 self.inner.unary(req, path, codec).await 2313 2599 } 2314 2600 pub async fn next( 2315 2601 &mut self, 2316 2602 request: impl tonic::IntoRequest<super::NextRequest>, 2317 2603 ) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status> { 2318 2318 - self.inner.ready().await.map_err(|e| { 2319 2319 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2320 2320 - })?; 2604 2604 + self.inner 2605 2605 + .ready() 2606 2606 + .await 2607 2607 + .map_err(|e| { 2608 2608 + tonic::Status::unknown( 2609 2609 + format!("Service was not ready: {}", e.into()), 2610 2610 + ) 2611 2611 + })?; 2321 2612 let codec = tonic::codec::ProstCodec::default(); 2322 2322 - let path = 2323 2323 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Next"); 2613 2613 + let path = http::uri::PathAndQuery::from_static( 2614 2614 + "/rockbox.v1alpha1.PlaybackService/Next", 2615 2615 + ); 2324 2616 let mut req = request.into_request(); 2325 2617 req.extensions_mut() 2326 2618 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Next")); ··· 2329 2621 pub async fn previous( 2330 2622 &mut self, 2331 2623 request: impl tonic::IntoRequest<super::PreviousRequest>, 2332 2332 - ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status> { 2333 2333 - self.inner.ready().await.map_err(|e| { 2334 2334 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2335 2335 - })?; 2624 2624 + ) -> std::result::Result< 2625 2625 + tonic::Response<super::PreviousResponse>, 2626 2626 + tonic::Status, 2627 2627 + > { 2628 2628 + self.inner 2629 2629 + .ready() 2630 2630 + .await 2631 2631 + .map_err(|e| { 2632 2632 + tonic::Status::unknown( 2633 2633 + format!("Service was not ready: {}", e.into()), 2634 2634 + ) 2635 2635 + })?; 2336 2636 let codec = tonic::codec::ProstCodec::default(); 2337 2337 - let path = 2338 2338 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Previous"); 2637 2637 + let path = http::uri::PathAndQuery::from_static( 2638 2638 + "/rockbox.v1alpha1.PlaybackService/Previous", 2639 2639 + ); 2339 2640 let mut req = request.into_request(); 2340 2340 - req.extensions_mut().insert(GrpcMethod::new( 2341 2341 - "rockbox.v1alpha1.PlaybackService", 2342 2342 - "Previous", 2343 2343 - )); 2641 2641 + req.extensions_mut() 2642 2642 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Previous")); 2344 2643 self.inner.unary(req, path, codec).await 2345 2644 } 2346 2645 pub async fn fast_forward_rewind( 2347 2646 &mut self, 2348 2647 request: impl tonic::IntoRequest<super::FastForwardRewindRequest>, 2349 2349 - ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status> 2350 2350 - { 2351 2351 - self.inner.ready().await.map_err(|e| { 2352 2352 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2353 2353 - })?; 2648 2648 + ) -> std::result::Result< 2649 2649 + tonic::Response<super::FastForwardRewindResponse>, 2650 2650 + tonic::Status, 2651 2651 + > { 2652 2652 + self.inner 2653 2653 + .ready() 2654 2654 + .await 2655 2655 + .map_err(|e| { 2656 2656 + tonic::Status::unknown( 2657 2657 + format!("Service was not ready: {}", e.into()), 2658 2658 + ) 2659 2659 + })?; 2354 2660 let codec = tonic::codec::ProstCodec::default(); 2355 2661 let path = http::uri::PathAndQuery::from_static( 2356 2662 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind", 2357 2663 ); 2358 2664 let mut req = request.into_request(); 2359 2359 - req.extensions_mut().insert(GrpcMethod::new( 2360 2360 - "rockbox.v1alpha1.PlaybackService", 2361 2361 - "FastForwardRewind", 2362 2362 - )); 2665 2665 + req.extensions_mut() 2666 2666 + .insert( 2667 2667 + GrpcMethod::new( 2668 2668 + "rockbox.v1alpha1.PlaybackService", 2669 2669 + "FastForwardRewind", 2670 2670 + ), 2671 2671 + ); 2363 2672 self.inner.unary(req, path, codec).await 2364 2673 } 2365 2674 pub async fn status( 2366 2675 &mut self, 2367 2676 request: impl tonic::IntoRequest<super::StatusRequest>, 2368 2677 ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> { 2369 2369 - self.inner.ready().await.map_err(|e| { 2370 2370 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2371 2371 - })?; 2678 2678 + self.inner 2679 2679 + .ready() 2680 2680 + .await 2681 2681 + .map_err(|e| { 2682 2682 + tonic::Status::unknown( 2683 2683 + format!("Service was not ready: {}", e.into()), 2684 2684 + ) 2685 2685 + })?; 2372 2686 let codec = tonic::codec::ProstCodec::default(); 2373 2373 - let path = 2374 2374 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Status"); 2687 2687 + let path = http::uri::PathAndQuery::from_static( 2688 2688 + "/rockbox.v1alpha1.PlaybackService/Status", 2689 2689 + ); 2375 2690 let mut req = request.into_request(); 2376 2376 - req.extensions_mut().insert(GrpcMethod::new( 2377 2377 - "rockbox.v1alpha1.PlaybackService", 2378 2378 - "Status", 2379 2379 - )); 2691 2691 + req.extensions_mut() 2692 2692 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Status")); 2380 2693 self.inner.unary(req, path, codec).await 2381 2694 } 2382 2695 pub async fn current_track( 2383 2696 &mut self, 2384 2697 request: impl tonic::IntoRequest<super::CurrentTrackRequest>, 2385 2385 - ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status> 2386 2386 - { 2387 2387 - self.inner.ready().await.map_err(|e| { 2388 2388 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2389 2389 - })?; 2698 2698 + ) -> std::result::Result< 2699 2699 + tonic::Response<super::CurrentTrackResponse>, 2700 2700 + tonic::Status, 2701 2701 + > { 2702 2702 + self.inner 2703 2703 + .ready() 2704 2704 + .await 2705 2705 + .map_err(|e| { 2706 2706 + tonic::Status::unknown( 2707 2707 + format!("Service was not ready: {}", e.into()), 2708 2708 + ) 2709 2709 + })?; 2390 2710 let codec = tonic::codec::ProstCodec::default(); 2391 2711 let path = http::uri::PathAndQuery::from_static( 2392 2712 "/rockbox.v1alpha1.PlaybackService/CurrentTrack", 2393 2713 ); 2394 2714 let mut req = request.into_request(); 2395 2395 - req.extensions_mut().insert(GrpcMethod::new( 2396 2396 - "rockbox.v1alpha1.PlaybackService", 2397 2397 - "CurrentTrack", 2398 2398 - )); 2715 2715 + req.extensions_mut() 2716 2716 + .insert( 2717 2717 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "CurrentTrack"), 2718 2718 + ); 2399 2719 self.inner.unary(req, path, codec).await 2400 2720 } 2401 2721 pub async fn next_track( 2402 2722 &mut self, 2403 2723 request: impl tonic::IntoRequest<super::NextTrackRequest>, 2404 2404 - ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status> { 2405 2405 - self.inner.ready().await.map_err(|e| { 2406 2406 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2407 2407 - })?; 2724 2724 + ) -> std::result::Result< 2725 2725 + tonic::Response<super::NextTrackResponse>, 2726 2726 + tonic::Status, 2727 2727 + > { 2728 2728 + self.inner 2729 2729 + .ready() 2730 2730 + .await 2731 2731 + .map_err(|e| { 2732 2732 + tonic::Status::unknown( 2733 2733 + format!("Service was not ready: {}", e.into()), 2734 2734 + ) 2735 2735 + })?; 2408 2736 let codec = tonic::codec::ProstCodec::default(); 2409 2409 - let path = 2410 2410 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/NextTrack"); 2737 2737 + let path = http::uri::PathAndQuery::from_static( 2738 2738 + "/rockbox.v1alpha1.PlaybackService/NextTrack", 2739 2739 + ); 2411 2740 let mut req = request.into_request(); 2412 2412 - req.extensions_mut().insert(GrpcMethod::new( 2413 2413 - "rockbox.v1alpha1.PlaybackService", 2414 2414 - "NextTrack", 2415 2415 - )); 2741 2741 + req.extensions_mut() 2742 2742 + .insert( 2743 2743 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "NextTrack"), 2744 2744 + ); 2416 2745 self.inner.unary(req, path, codec).await 2417 2746 } 2418 2747 pub async fn flush_and_reload_tracks( 2419 2748 &mut self, 2420 2749 request: impl tonic::IntoRequest<super::FlushAndReloadTracksRequest>, 2421 2421 - ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status> 2422 2422 - { 2423 2423 - self.inner.ready().await.map_err(|e| { 2424 2424 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2425 2425 - })?; 2750 2750 + ) -> std::result::Result< 2751 2751 + tonic::Response<super::FlushAndReloadTracksResponse>, 2752 2752 + tonic::Status, 2753 2753 + > { 2754 2754 + self.inner 2755 2755 + .ready() 2756 2756 + .await 2757 2757 + .map_err(|e| { 2758 2758 + tonic::Status::unknown( 2759 2759 + format!("Service was not ready: {}", e.into()), 2760 2760 + ) 2761 2761 + })?; 2426 2762 let codec = tonic::codec::ProstCodec::default(); 2427 2763 let path = http::uri::PathAndQuery::from_static( 2428 2764 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks", 2429 2765 ); 2430 2766 let mut req = request.into_request(); 2431 2431 - req.extensions_mut().insert(GrpcMethod::new( 2432 2432 - "rockbox.v1alpha1.PlaybackService", 2433 2433 - "FlushAndReloadTracks", 2434 2434 - )); 2767 2767 + req.extensions_mut() 2768 2768 + .insert( 2769 2769 + GrpcMethod::new( 2770 2770 + "rockbox.v1alpha1.PlaybackService", 2771 2771 + "FlushAndReloadTracks", 2772 2772 + ), 2773 2773 + ); 2435 2774 self.inner.unary(req, path, codec).await 2436 2775 } 2437 2776 pub async fn get_file_position( 2438 2777 &mut self, 2439 2778 request: impl tonic::IntoRequest<super::GetFilePositionRequest>, 2440 2440 - ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status> 2441 2441 - { 2442 2442 - self.inner.ready().await.map_err(|e| { 2443 2443 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2444 2444 - })?; 2779 2779 + ) -> std::result::Result< 2780 2780 + tonic::Response<super::GetFilePositionResponse>, 2781 2781 + tonic::Status, 2782 2782 + > { 2783 2783 + self.inner 2784 2784 + .ready() 2785 2785 + .await 2786 2786 + .map_err(|e| { 2787 2787 + tonic::Status::unknown( 2788 2788 + format!("Service was not ready: {}", e.into()), 2789 2789 + ) 2790 2790 + })?; 2445 2791 let codec = tonic::codec::ProstCodec::default(); 2446 2792 let path = http::uri::PathAndQuery::from_static( 2447 2793 "/rockbox.v1alpha1.PlaybackService/GetFilePosition", 2448 2794 ); 2449 2795 let mut req = request.into_request(); 2450 2450 - req.extensions_mut().insert(GrpcMethod::new( 2451 2451 - "rockbox.v1alpha1.PlaybackService", 2452 2452 - "GetFilePosition", 2453 2453 - )); 2796 2796 + req.extensions_mut() 2797 2797 + .insert( 2798 2798 + GrpcMethod::new( 2799 2799 + "rockbox.v1alpha1.PlaybackService", 2800 2800 + "GetFilePosition", 2801 2801 + ), 2802 2802 + ); 2454 2803 self.inner.unary(req, path, codec).await 2455 2804 } 2456 2805 pub async fn hard_stop( 2457 2806 &mut self, 2458 2807 request: impl tonic::IntoRequest<super::HardStopRequest>, 2459 2459 - ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status> { 2460 2460 - self.inner.ready().await.map_err(|e| { 2461 2461 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2462 2462 - })?; 2808 2808 + ) -> std::result::Result< 2809 2809 + tonic::Response<super::HardStopResponse>, 2810 2810 + tonic::Status, 2811 2811 + > { 2812 2812 + self.inner 2813 2813 + .ready() 2814 2814 + .await 2815 2815 + .map_err(|e| { 2816 2816 + tonic::Status::unknown( 2817 2817 + format!("Service was not ready: {}", e.into()), 2818 2818 + ) 2819 2819 + })?; 2463 2820 let codec = tonic::codec::ProstCodec::default(); 2464 2464 - let path = 2465 2465 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/HardStop"); 2821 2821 + let path = http::uri::PathAndQuery::from_static( 2822 2822 + "/rockbox.v1alpha1.PlaybackService/HardStop", 2823 2823 + ); 2466 2824 let mut req = request.into_request(); 2467 2467 - req.extensions_mut().insert(GrpcMethod::new( 2468 2468 - "rockbox.v1alpha1.PlaybackService", 2469 2469 - "HardStop", 2470 2470 - )); 2825 2825 + req.extensions_mut() 2826 2826 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "HardStop")); 2471 2827 self.inner.unary(req, path, codec).await 2472 2828 } 2473 2829 pub async fn play_album( 2474 2830 &mut self, 2475 2831 request: impl tonic::IntoRequest<super::PlayAlbumRequest>, 2476 2476 - ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status> { 2477 2477 - self.inner.ready().await.map_err(|e| { 2478 2478 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2479 2479 - })?; 2832 2832 + ) -> std::result::Result< 2833 2833 + tonic::Response<super::PlayAlbumResponse>, 2834 2834 + tonic::Status, 2835 2835 + > { 2836 2836 + self.inner 2837 2837 + .ready() 2838 2838 + .await 2839 2839 + .map_err(|e| { 2840 2840 + tonic::Status::unknown( 2841 2841 + format!("Service was not ready: {}", e.into()), 2842 2842 + ) 2843 2843 + })?; 2480 2844 let codec = tonic::codec::ProstCodec::default(); 2481 2481 - let path = 2482 2482 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayAlbum"); 2845 2845 + let path = http::uri::PathAndQuery::from_static( 2846 2846 + "/rockbox.v1alpha1.PlaybackService/PlayAlbum", 2847 2847 + ); 2483 2848 let mut req = request.into_request(); 2484 2484 - req.extensions_mut().insert(GrpcMethod::new( 2485 2485 - "rockbox.v1alpha1.PlaybackService", 2486 2486 - "PlayAlbum", 2487 2487 - )); 2849 2849 + req.extensions_mut() 2850 2850 + .insert( 2851 2851 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAlbum"), 2852 2852 + ); 2488 2853 self.inner.unary(req, path, codec).await 2489 2854 } 2490 2855 pub async fn play_artist_tracks( 2491 2856 &mut self, 2492 2857 request: impl tonic::IntoRequest<super::PlayArtistTracksRequest>, 2493 2493 - ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status> 2494 2494 - { 2495 2495 - self.inner.ready().await.map_err(|e| { 2496 2496 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2497 2497 - })?; 2858 2858 + ) -> std::result::Result< 2859 2859 + tonic::Response<super::PlayArtistTracksResponse>, 2860 2860 + tonic::Status, 2861 2861 + > { 2862 2862 + self.inner 2863 2863 + .ready() 2864 2864 + .await 2865 2865 + .map_err(|e| { 2866 2866 + tonic::Status::unknown( 2867 2867 + format!("Service was not ready: {}", e.into()), 2868 2868 + ) 2869 2869 + })?; 2498 2870 let codec = tonic::codec::ProstCodec::default(); 2499 2871 let path = http::uri::PathAndQuery::from_static( 2500 2872 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks", 2501 2873 ); 2502 2874 let mut req = request.into_request(); 2503 2503 - req.extensions_mut().insert(GrpcMethod::new( 2504 2504 - "rockbox.v1alpha1.PlaybackService", 2505 2505 - "PlayArtistTracks", 2506 2506 - )); 2875 2875 + req.extensions_mut() 2876 2876 + .insert( 2877 2877 + GrpcMethod::new( 2878 2878 + "rockbox.v1alpha1.PlaybackService", 2879 2879 + "PlayArtistTracks", 2880 2880 + ), 2881 2881 + ); 2507 2882 self.inner.unary(req, path, codec).await 2508 2883 } 2509 2884 pub async fn play_playlist( 2510 2885 &mut self, 2511 2886 request: impl tonic::IntoRequest<super::PlayPlaylistRequest>, 2512 2512 - ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status> 2513 2513 - { 2514 2514 - self.inner.ready().await.map_err(|e| { 2515 2515 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2516 2516 - })?; 2887 2887 + ) -> std::result::Result< 2888 2888 + tonic::Response<super::PlayPlaylistResponse>, 2889 2889 + tonic::Status, 2890 2890 + > { 2891 2891 + self.inner 2892 2892 + .ready() 2893 2893 + .await 2894 2894 + .map_err(|e| { 2895 2895 + tonic::Status::unknown( 2896 2896 + format!("Service was not ready: {}", e.into()), 2897 2897 + ) 2898 2898 + })?; 2517 2899 let codec = tonic::codec::ProstCodec::default(); 2518 2900 let path = http::uri::PathAndQuery::from_static( 2519 2901 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist", 2520 2902 ); 2521 2903 let mut req = request.into_request(); 2522 2522 - req.extensions_mut().insert(GrpcMethod::new( 2523 2523 - "rockbox.v1alpha1.PlaybackService", 2524 2524 - "PlayPlaylist", 2525 2525 - )); 2904 2904 + req.extensions_mut() 2905 2905 + .insert( 2906 2906 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayPlaylist"), 2907 2907 + ); 2526 2908 self.inner.unary(req, path, codec).await 2527 2909 } 2528 2910 pub async fn play_directory( 2529 2911 &mut self, 2530 2912 request: impl tonic::IntoRequest<super::PlayDirectoryRequest>, 2531 2531 - ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status> 2532 2532 - { 2533 2533 - self.inner.ready().await.map_err(|e| { 2534 2534 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2535 2535 - })?; 2913 2913 + ) -> std::result::Result< 2914 2914 + tonic::Response<super::PlayDirectoryResponse>, 2915 2915 + tonic::Status, 2916 2916 + > { 2917 2917 + self.inner 2918 2918 + .ready() 2919 2919 + .await 2920 2920 + .map_err(|e| { 2921 2921 + tonic::Status::unknown( 2922 2922 + format!("Service was not ready: {}", e.into()), 2923 2923 + ) 2924 2924 + })?; 2536 2925 let codec = tonic::codec::ProstCodec::default(); 2537 2926 let path = http::uri::PathAndQuery::from_static( 2538 2927 "/rockbox.v1alpha1.PlaybackService/PlayDirectory", 2539 2928 ); 2540 2929 let mut req = request.into_request(); 2541 2541 - req.extensions_mut().insert(GrpcMethod::new( 2542 2542 - "rockbox.v1alpha1.PlaybackService", 2543 2543 - "PlayDirectory", 2544 2544 - )); 2930 2930 + req.extensions_mut() 2931 2931 + .insert( 2932 2932 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayDirectory"), 2933 2933 + ); 2545 2934 self.inner.unary(req, path, codec).await 2546 2935 } 2547 2936 pub async fn play_music_directory( 2548 2937 &mut self, 2549 2938 request: impl tonic::IntoRequest<super::PlayMusicDirectoryRequest>, 2550 2550 - ) -> std::result::Result<tonic::Response<super::PlayMusicDirectoryResponse>, tonic::Status> 2551 2551 - { 2552 2552 - self.inner.ready().await.map_err(|e| { 2553 2553 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2554 2554 - })?; 2939 2939 + ) -> std::result::Result< 2940 2940 + tonic::Response<super::PlayMusicDirectoryResponse>, 2941 2941 + tonic::Status, 2942 2942 + > { 2943 2943 + self.inner 2944 2944 + .ready() 2945 2945 + .await 2946 2946 + .map_err(|e| { 2947 2947 + tonic::Status::unknown( 2948 2948 + format!("Service was not ready: {}", e.into()), 2949 2949 + ) 2950 2950 + })?; 2555 2951 let codec = tonic::codec::ProstCodec::default(); 2556 2952 let path = http::uri::PathAndQuery::from_static( 2557 2953 "/rockbox.v1alpha1.PlaybackService/PlayMusicDirectory", 2558 2954 ); 2559 2955 let mut req = request.into_request(); 2560 2560 - req.extensions_mut().insert(GrpcMethod::new( 2561 2561 - "rockbox.v1alpha1.PlaybackService", 2562 2562 - "PlayMusicDirectory", 2563 2563 - )); 2956 2956 + req.extensions_mut() 2957 2957 + .insert( 2958 2958 + GrpcMethod::new( 2959 2959 + "rockbox.v1alpha1.PlaybackService", 2960 2960 + "PlayMusicDirectory", 2961 2961 + ), 2962 2962 + ); 2564 2963 self.inner.unary(req, path, codec).await 2565 2964 } 2566 2965 pub async fn play_track( 2567 2966 &mut self, 2568 2967 request: impl tonic::IntoRequest<super::PlayTrackRequest>, 2569 2569 - ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status> { 2570 2570 - self.inner.ready().await.map_err(|e| { 2571 2571 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2572 2572 - })?; 2968 2968 + ) -> std::result::Result< 2969 2969 + tonic::Response<super::PlayTrackResponse>, 2970 2970 + tonic::Status, 2971 2971 + > { 2972 2972 + self.inner 2973 2973 + .ready() 2974 2974 + .await 2975 2975 + .map_err(|e| { 2976 2976 + tonic::Status::unknown( 2977 2977 + format!("Service was not ready: {}", e.into()), 2978 2978 + ) 2979 2979 + })?; 2573 2980 let codec = tonic::codec::ProstCodec::default(); 2574 2574 - let path = 2575 2575 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayTrack"); 2981 2981 + let path = http::uri::PathAndQuery::from_static( 2982 2982 + "/rockbox.v1alpha1.PlaybackService/PlayTrack", 2983 2983 + ); 2576 2984 let mut req = request.into_request(); 2577 2577 - req.extensions_mut().insert(GrpcMethod::new( 2578 2578 - "rockbox.v1alpha1.PlaybackService", 2579 2579 - "PlayTrack", 2580 2580 - )); 2985 2985 + req.extensions_mut() 2986 2986 + .insert( 2987 2987 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayTrack"), 2988 2988 + ); 2581 2989 self.inner.unary(req, path, codec).await 2582 2990 } 2583 2991 pub async fn play_liked_tracks( 2584 2992 &mut self, 2585 2993 request: impl tonic::IntoRequest<super::PlayLikedTracksRequest>, 2586 2586 - ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status> 2587 2587 - { 2588 2588 - self.inner.ready().await.map_err(|e| { 2589 2589 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2590 2590 - })?; 2994 2994 + ) -> std::result::Result< 2995 2995 + tonic::Response<super::PlayLikedTracksResponse>, 2996 2996 + tonic::Status, 2997 2997 + > { 2998 2998 + self.inner 2999 2999 + .ready() 3000 3000 + .await 3001 3001 + .map_err(|e| { 3002 3002 + tonic::Status::unknown( 3003 3003 + format!("Service was not ready: {}", e.into()), 3004 3004 + ) 3005 3005 + })?; 2591 3006 let codec = tonic::codec::ProstCodec::default(); 2592 3007 let path = http::uri::PathAndQuery::from_static( 2593 3008 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks", 2594 3009 ); 2595 3010 let mut req = request.into_request(); 2596 2596 - req.extensions_mut().insert(GrpcMethod::new( 2597 2597 - "rockbox.v1alpha1.PlaybackService", 2598 2598 - "PlayLikedTracks", 2599 2599 - )); 3011 3011 + req.extensions_mut() 3012 3012 + .insert( 3013 3013 + GrpcMethod::new( 3014 3014 + "rockbox.v1alpha1.PlaybackService", 3015 3015 + "PlayLikedTracks", 3016 3016 + ), 3017 3017 + ); 2600 3018 self.inner.unary(req, path, codec).await 2601 3019 } 2602 3020 pub async fn play_all_tracks( 2603 3021 &mut self, 2604 3022 request: impl tonic::IntoRequest<super::PlayAllTracksRequest>, 2605 2605 - ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status> 2606 2606 - { 2607 2607 - self.inner.ready().await.map_err(|e| { 2608 2608 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2609 2609 - })?; 3023 3023 + ) -> std::result::Result< 3024 3024 + tonic::Response<super::PlayAllTracksResponse>, 3025 3025 + tonic::Status, 3026 3026 + > { 3027 3027 + self.inner 3028 3028 + .ready() 3029 3029 + .await 3030 3030 + .map_err(|e| { 3031 3031 + tonic::Status::unknown( 3032 3032 + format!("Service was not ready: {}", e.into()), 3033 3033 + ) 3034 3034 + })?; 2610 3035 let codec = tonic::codec::ProstCodec::default(); 2611 3036 let path = http::uri::PathAndQuery::from_static( 2612 3037 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks", 2613 3038 ); 2614 3039 let mut req = request.into_request(); 2615 2615 - req.extensions_mut().insert(GrpcMethod::new( 2616 2616 - "rockbox.v1alpha1.PlaybackService", 2617 2617 - "PlayAllTracks", 2618 2618 - )); 3040 3040 + req.extensions_mut() 3041 3041 + .insert( 3042 3042 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAllTracks"), 3043 3043 + ); 2619 3044 self.inner.unary(req, path, codec).await 2620 3045 } 2621 3046 pub async fn stream_current_track( ··· 2625 3050 tonic::Response<tonic::codec::Streaming<super::CurrentTrackResponse>>, 2626 3051 tonic::Status, 2627 3052 > { 2628 2628 - self.inner.ready().await.map_err(|e| { 2629 2629 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2630 2630 - })?; 3053 3053 + self.inner 3054 3054 + .ready() 3055 3055 + .await 3056 3056 + .map_err(|e| { 3057 3057 + tonic::Status::unknown( 3058 3058 + format!("Service was not ready: {}", e.into()), 3059 3059 + ) 3060 3060 + })?; 2631 3061 let codec = tonic::codec::ProstCodec::default(); 2632 3062 let path = http::uri::PathAndQuery::from_static( 2633 3063 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack", 2634 3064 ); 2635 3065 let mut req = request.into_request(); 2636 2636 - req.extensions_mut().insert(GrpcMethod::new( 2637 2637 - "rockbox.v1alpha1.PlaybackService", 2638 2638 - "StreamCurrentTrack", 2639 2639 - )); 3066 3066 + req.extensions_mut() 3067 3067 + .insert( 3068 3068 + GrpcMethod::new( 3069 3069 + "rockbox.v1alpha1.PlaybackService", 3070 3070 + "StreamCurrentTrack", 3071 3071 + ), 3072 3072 + ); 2640 3073 self.inner.server_streaming(req, path, codec).await 2641 3074 } 2642 3075 pub async fn stream_status( ··· 2646 3079 tonic::Response<tonic::codec::Streaming<super::StatusResponse>>, 2647 3080 tonic::Status, 2648 3081 > { 2649 2649 - self.inner.ready().await.map_err(|e| { 2650 2650 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2651 2651 - })?; 3082 3082 + self.inner 3083 3083 + .ready() 3084 3084 + .await 3085 3085 + .map_err(|e| { 3086 3086 + tonic::Status::unknown( 3087 3087 + format!("Service was not ready: {}", e.into()), 3088 3088 + ) 3089 3089 + })?; 2652 3090 let codec = tonic::codec::ProstCodec::default(); 2653 3091 let path = http::uri::PathAndQuery::from_static( 2654 3092 "/rockbox.v1alpha1.PlaybackService/StreamStatus", 2655 3093 ); 2656 3094 let mut req = request.into_request(); 2657 2657 - req.extensions_mut().insert(GrpcMethod::new( 2658 2658 - "rockbox.v1alpha1.PlaybackService", 2659 2659 - "StreamStatus", 2660 2660 - )); 3095 3095 + req.extensions_mut() 3096 3096 + .insert( 3097 3097 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamStatus"), 3098 3098 + ); 2661 3099 self.inner.server_streaming(req, path, codec).await 2662 3100 } 2663 3101 pub async fn stream_playlist( ··· 2667 3105 tonic::Response<tonic::codec::Streaming<super::PlaylistResponse>>, 2668 3106 tonic::Status, 2669 3107 > { 2670 2670 - self.inner.ready().await.map_err(|e| { 2671 2671 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2672 2672 - })?; 3108 3108 + self.inner 3109 3109 + .ready() 3110 3110 + .await 3111 3111 + .map_err(|e| { 3112 3112 + tonic::Status::unknown( 3113 3113 + format!("Service was not ready: {}", e.into()), 3114 3114 + ) 3115 3115 + })?; 2673 3116 let codec = tonic::codec::ProstCodec::default(); 2674 3117 let path = http::uri::PathAndQuery::from_static( 2675 3118 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist", 2676 3119 ); 2677 3120 let mut req = request.into_request(); 2678 2678 - req.extensions_mut().insert(GrpcMethod::new( 2679 2679 - "rockbox.v1alpha1.PlaybackService", 2680 2680 - "StreamPlaylist", 2681 2681 - )); 3121 3121 + req.extensions_mut() 3122 3122 + .insert( 3123 3123 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamPlaylist"), 3124 3124 + ); 2682 3125 self.inner.server_streaming(req, path, codec).await 2683 3126 } 2684 3127 } ··· 2690 3133 dead_code, 2691 3134 missing_docs, 2692 3135 clippy::wildcard_imports, 2693 2693 - clippy::let_unit_value 3136 3136 + clippy::let_unit_value, 2694 3137 )] 2695 3138 use tonic::codegen::*; 2696 3139 /// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer. ··· 2707 3150 async fn play_or_pause( 2708 3151 &self, 2709 3152 request: tonic::Request<super::PlayOrPauseRequest>, 2710 2710 - ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status>; 3153 3153 + ) -> std::result::Result< 3154 3154 + tonic::Response<super::PlayOrPauseResponse>, 3155 3155 + tonic::Status, 3156 3156 + >; 2711 3157 async fn resume( 2712 3158 &self, 2713 3159 request: tonic::Request<super::ResumeRequest>, ··· 2719 3165 async fn previous( 2720 3166 &self, 2721 3167 request: tonic::Request<super::PreviousRequest>, 2722 2722 - ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status>; 3168 3168 + ) -> std::result::Result< 3169 3169 + tonic::Response<super::PreviousResponse>, 3170 3170 + tonic::Status, 3171 3171 + >; 2723 3172 async fn fast_forward_rewind( 2724 3173 &self, 2725 3174 request: tonic::Request<super::FastForwardRewindRequest>, 2726 2726 - ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>; 3175 3175 + ) -> std::result::Result< 3176 3176 + tonic::Response<super::FastForwardRewindResponse>, 3177 3177 + tonic::Status, 3178 3178 + >; 2727 3179 async fn status( 2728 3180 &self, 2729 3181 request: tonic::Request<super::StatusRequest>, ··· 2731 3183 async fn current_track( 2732 3184 &self, 2733 3185 request: tonic::Request<super::CurrentTrackRequest>, 2734 2734 - ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status>; 3186 3186 + ) -> std::result::Result< 3187 3187 + tonic::Response<super::CurrentTrackResponse>, 3188 3188 + tonic::Status, 3189 3189 + >; 2735 3190 async fn next_track( 2736 3191 &self, 2737 3192 request: tonic::Request<super::NextTrackRequest>, 2738 2738 - ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status>; 3193 3193 + ) -> std::result::Result< 3194 3194 + tonic::Response<super::NextTrackResponse>, 3195 3195 + tonic::Status, 3196 3196 + >; 2739 3197 async fn flush_and_reload_tracks( 2740 3198 &self, 2741 3199 request: tonic::Request<super::FlushAndReloadTracksRequest>, 2742 2742 - ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status>; 3200 3200 + ) -> std::result::Result< 3201 3201 + tonic::Response<super::FlushAndReloadTracksResponse>, 3202 3202 + tonic::Status, 3203 3203 + >; 2743 3204 async fn get_file_position( 2744 3205 &self, 2745 3206 request: tonic::Request<super::GetFilePositionRequest>, 2746 2746 - ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status>; 3207 3207 + ) -> std::result::Result< 3208 3208 + tonic::Response<super::GetFilePositionResponse>, 3209 3209 + tonic::Status, 3210 3210 + >; 2747 3211 async fn hard_stop( 2748 3212 &self, 2749 3213 request: tonic::Request<super::HardStopRequest>, 2750 2750 - ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status>; 3214 3214 + ) -> std::result::Result< 3215 3215 + tonic::Response<super::HardStopResponse>, 3216 3216 + tonic::Status, 3217 3217 + >; 2751 3218 async fn play_album( 2752 3219 &self, 2753 3220 request: tonic::Request<super::PlayAlbumRequest>, 2754 2754 - ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status>; 3221 3221 + ) -> std::result::Result< 3222 3222 + tonic::Response<super::PlayAlbumResponse>, 3223 3223 + tonic::Status, 3224 3224 + >; 2755 3225 async fn play_artist_tracks( 2756 3226 &self, 2757 3227 request: tonic::Request<super::PlayArtistTracksRequest>, 2758 2758 - ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status>; 3228 3228 + ) -> std::result::Result< 3229 3229 + tonic::Response<super::PlayArtistTracksResponse>, 3230 3230 + tonic::Status, 3231 3231 + >; 2759 3232 async fn play_playlist( 2760 3233 &self, 2761 3234 request: tonic::Request<super::PlayPlaylistRequest>, 2762 2762 - ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status>; 3235 3235 + ) -> std::result::Result< 3236 3236 + tonic::Response<super::PlayPlaylistResponse>, 3237 3237 + tonic::Status, 3238 3238 + >; 2763 3239 async fn play_directory( 2764 3240 &self, 2765 3241 request: tonic::Request<super::PlayDirectoryRequest>, 2766 2766 - ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>; 3242 3242 + ) -> std::result::Result< 3243 3243 + tonic::Response<super::PlayDirectoryResponse>, 3244 3244 + tonic::Status, 3245 3245 + >; 2767 3246 async fn play_music_directory( 2768 3247 &self, 2769 3248 request: tonic::Request<super::PlayMusicDirectoryRequest>, 2770 2770 - ) -> std::result::Result<tonic::Response<super::PlayMusicDirectoryResponse>, tonic::Status>; 3249 3249 + ) -> std::result::Result< 3250 3250 + tonic::Response<super::PlayMusicDirectoryResponse>, 3251 3251 + tonic::Status, 3252 3252 + >; 2771 3253 async fn play_track( 2772 3254 &self, 2773 3255 request: tonic::Request<super::PlayTrackRequest>, 2774 2774 - ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status>; 3256 3256 + ) -> std::result::Result< 3257 3257 + tonic::Response<super::PlayTrackResponse>, 3258 3258 + tonic::Status, 3259 3259 + >; 2775 3260 async fn play_liked_tracks( 2776 3261 &self, 2777 3262 request: tonic::Request<super::PlayLikedTracksRequest>, 2778 2778 - ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status>; 3263 3263 + ) -> std::result::Result< 3264 3264 + tonic::Response<super::PlayLikedTracksResponse>, 3265 3265 + tonic::Status, 3266 3266 + >; 2779 3267 async fn play_all_tracks( 2780 3268 &self, 2781 3269 request: tonic::Request<super::PlayAllTracksRequest>, 2782 2782 - ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>; 3270 3270 + ) -> std::result::Result< 3271 3271 + tonic::Response<super::PlayAllTracksResponse>, 3272 3272 + tonic::Status, 3273 3273 + >; 2783 3274 /// Server streaming response type for the StreamCurrentTrack method. 2784 3275 type StreamCurrentTrackStream: tonic::codegen::tokio_stream::Stream< 2785 3276 Item = std::result::Result<super::CurrentTrackResponse, tonic::Status>, 2786 2786 - > + std::marker::Send 3277 3277 + > 3278 3278 + + std::marker::Send 2787 3279 + 'static; 2788 3280 async fn stream_current_track( 2789 3281 &self, 2790 3282 request: tonic::Request<super::StreamCurrentTrackRequest>, 2791 2791 - ) -> std::result::Result<tonic::Response<Self::StreamCurrentTrackStream>, tonic::Status>; 3283 3283 + ) -> std::result::Result< 3284 3284 + tonic::Response<Self::StreamCurrentTrackStream>, 3285 3285 + tonic::Status, 3286 3286 + >; 2792 3287 /// Server streaming response type for the StreamStatus method. 2793 3288 type StreamStatusStream: tonic::codegen::tokio_stream::Stream< 2794 3289 Item = std::result::Result<super::StatusResponse, tonic::Status>, 2795 2795 - > + std::marker::Send 3290 3290 + > 3291 3291 + + std::marker::Send 2796 3292 + 'static; 2797 3293 async fn stream_status( 2798 3294 &self, 2799 3295 request: tonic::Request<super::StreamStatusRequest>, 2800 2800 - ) -> std::result::Result<tonic::Response<Self::StreamStatusStream>, tonic::Status>; 3296 3296 + ) -> std::result::Result< 3297 3297 + tonic::Response<Self::StreamStatusStream>, 3298 3298 + tonic::Status, 3299 3299 + >; 2801 3300 /// Server streaming response type for the StreamPlaylist method. 2802 3301 type StreamPlaylistStream: tonic::codegen::tokio_stream::Stream< 2803 3302 Item = std::result::Result<super::PlaylistResponse, tonic::Status>, 2804 2804 - > + std::marker::Send 3303 3303 + > 3304 3304 + + std::marker::Send 2805 3305 + 'static; 2806 3306 async fn stream_playlist( 2807 3307 &self, 2808 3308 request: tonic::Request<super::StreamPlaylistRequest>, 2809 2809 - ) -> std::result::Result<tonic::Response<Self::StreamPlaylistStream>, tonic::Status>; 3309 3309 + ) -> std::result::Result< 3310 3310 + tonic::Response<Self::StreamPlaylistStream>, 3311 3311 + tonic::Status, 3312 3312 + >; 2810 3313 } 2811 3314 #[derive(Debug)] 2812 3315 pub struct PlaybackServiceServer<T> { ··· 2829 3332 max_encoding_message_size: None, 2830 3333 } 2831 3334 } 2832 2832 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 3335 3335 + pub fn with_interceptor<F>( 3336 3336 + inner: T, 3337 3337 + interceptor: F, 3338 3338 + ) -> InterceptedService<Self, F> 2833 3339 where 2834 3340 F: tonic::service::Interceptor, 2835 3341 { ··· 2884 3390 "/rockbox.v1alpha1.PlaybackService/Play" => { 2885 3391 #[allow(non_camel_case_types)] 2886 3392 struct PlaySvc<T: PlaybackService>(pub Arc<T>); 2887 2887 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 3393 3393 + impl< 3394 3394 + T: PlaybackService, 3395 3395 + > tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 2888 3396 type Response = super::PlayResponse; 2889 2889 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3397 3397 + type Future = BoxFuture< 3398 3398 + tonic::Response<Self::Response>, 3399 3399 + tonic::Status, 3400 3400 + >; 2890 3401 fn call( 2891 3402 &mut self, 2892 3403 request: tonic::Request<super::PlayRequest>, 2893 3404 ) -> Self::Future { 2894 3405 let inner = Arc::clone(&self.0); 2895 2895 - let fut = 2896 2896 - async move { <T as PlaybackService>::play(&inner, request).await }; 3406 3406 + let fut = async move { 3407 3407 + <T as PlaybackService>::play(&inner, request).await 3408 3408 + }; 2897 3409 Box::pin(fut) 2898 3410 } 2899 3411 } ··· 2922 3434 "/rockbox.v1alpha1.PlaybackService/Pause" => { 2923 3435 #[allow(non_camel_case_types)] 2924 3436 struct PauseSvc<T: PlaybackService>(pub Arc<T>); 2925 2925 - impl<T: PlaybackService> tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 3437 3437 + impl< 3438 3438 + T: PlaybackService, 3439 3439 + > tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 2926 3440 type Response = super::PauseResponse; 2927 2927 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3441 3441 + type Future = BoxFuture< 3442 3442 + tonic::Response<Self::Response>, 3443 3443 + tonic::Status, 3444 3444 + >; 2928 3445 fn call( 2929 3446 &mut self, 2930 3447 request: tonic::Request<super::PauseRequest>, 2931 3448 ) -> Self::Future { 2932 3449 let inner = Arc::clone(&self.0); 2933 2933 - let fut = 2934 2934 - async move { <T as PlaybackService>::pause(&inner, request).await }; 3450 3450 + let fut = async move { 3451 3451 + <T as PlaybackService>::pause(&inner, request).await 3452 3452 + }; 2935 3453 Box::pin(fut) 2936 3454 } 2937 3455 } ··· 2960 3478 "/rockbox.v1alpha1.PlaybackService/PlayOrPause" => { 2961 3479 #[allow(non_camel_case_types)] 2962 3480 struct PlayOrPauseSvc<T: PlaybackService>(pub Arc<T>); 2963 2963 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayOrPauseRequest> 2964 2964 - for PlayOrPauseSvc<T> 2965 2965 - { 3481 3481 + impl< 3482 3482 + T: PlaybackService, 3483 3483 + > tonic::server::UnaryService<super::PlayOrPauseRequest> 3484 3484 + for PlayOrPauseSvc<T> { 2966 3485 type Response = super::PlayOrPauseResponse; 2967 2967 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3486 3486 + type Future = BoxFuture< 3487 3487 + tonic::Response<Self::Response>, 3488 3488 + tonic::Status, 3489 3489 + >; 2968 3490 fn call( 2969 3491 &mut self, 2970 3492 request: tonic::Request<super::PlayOrPauseRequest>, ··· 3001 3523 "/rockbox.v1alpha1.PlaybackService/Resume" => { 3002 3524 #[allow(non_camel_case_types)] 3003 3525 struct ResumeSvc<T: PlaybackService>(pub Arc<T>); 3004 3004 - impl<T: PlaybackService> tonic::server::UnaryService<super::ResumeRequest> for ResumeSvc<T> { 3526 3526 + impl< 3527 3527 + T: PlaybackService, 3528 3528 + > tonic::server::UnaryService<super::ResumeRequest> 3529 3529 + for ResumeSvc<T> { 3005 3530 type Response = super::ResumeResponse; 3006 3006 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3531 3531 + type Future = BoxFuture< 3532 3532 + tonic::Response<Self::Response>, 3533 3533 + tonic::Status, 3534 3534 + >; 3007 3535 fn call( 3008 3536 &mut self, 3009 3537 request: tonic::Request<super::ResumeRequest>, ··· 3040 3568 "/rockbox.v1alpha1.PlaybackService/Next" => { 3041 3569 #[allow(non_camel_case_types)] 3042 3570 struct NextSvc<T: PlaybackService>(pub Arc<T>); 3043 3043 - impl<T: PlaybackService> tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 3571 3571 + impl< 3572 3572 + T: PlaybackService, 3573 3573 + > tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 3044 3574 type Response = super::NextResponse; 3045 3045 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3575 3575 + type Future = BoxFuture< 3576 3576 + tonic::Response<Self::Response>, 3577 3577 + tonic::Status, 3578 3578 + >; 3046 3579 fn call( 3047 3580 &mut self, 3048 3581 request: tonic::Request<super::NextRequest>, 3049 3582 ) -> Self::Future { 3050 3583 let inner = Arc::clone(&self.0); 3051 3051 - let fut = 3052 3052 - async move { <T as PlaybackService>::next(&inner, request).await }; 3584 3584 + let fut = async move { 3585 3585 + <T as PlaybackService>::next(&inner, request).await 3586 3586 + }; 3053 3587 Box::pin(fut) 3054 3588 } 3055 3589 } ··· 3078 3612 "/rockbox.v1alpha1.PlaybackService/Previous" => { 3079 3613 #[allow(non_camel_case_types)] 3080 3614 struct PreviousSvc<T: PlaybackService>(pub Arc<T>); 3081 3081 - impl<T: PlaybackService> tonic::server::UnaryService<super::PreviousRequest> for PreviousSvc<T> { 3615 3615 + impl< 3616 3616 + T: PlaybackService, 3617 3617 + > tonic::server::UnaryService<super::PreviousRequest> 3618 3618 + for PreviousSvc<T> { 3082 3619 type Response = super::PreviousResponse; 3083 3083 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3620 3620 + type Future = BoxFuture< 3621 3621 + tonic::Response<Self::Response>, 3622 3622 + tonic::Status, 3623 3623 + >; 3084 3624 fn call( 3085 3625 &mut self, 3086 3626 request: tonic::Request<super::PreviousRequest>, ··· 3117 3657 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind" => { 3118 3658 #[allow(non_camel_case_types)] 3119 3659 struct FastForwardRewindSvc<T: PlaybackService>(pub Arc<T>); 3120 3120 - impl<T: PlaybackService> 3121 3121 - tonic::server::UnaryService<super::FastForwardRewindRequest> 3122 3122 - for FastForwardRewindSvc<T> 3123 3123 - { 3660 3660 + impl< 3661 3661 + T: PlaybackService, 3662 3662 + > tonic::server::UnaryService<super::FastForwardRewindRequest> 3663 3663 + for FastForwardRewindSvc<T> { 3124 3664 type Response = super::FastForwardRewindResponse; 3125 3125 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3665 3665 + type Future = BoxFuture< 3666 3666 + tonic::Response<Self::Response>, 3667 3667 + tonic::Status, 3668 3668 + >; 3126 3669 fn call( 3127 3670 &mut self, 3128 3671 request: tonic::Request<super::FastForwardRewindRequest>, 3129 3672 ) -> Self::Future { 3130 3673 let inner = Arc::clone(&self.0); 3131 3674 let fut = async move { 3132 3132 - <T as PlaybackService>::fast_forward_rewind(&inner, request).await 3675 3675 + <T as PlaybackService>::fast_forward_rewind(&inner, request) 3676 3676 + .await 3133 3677 }; 3134 3678 Box::pin(fut) 3135 3679 } ··· 3159 3703 "/rockbox.v1alpha1.PlaybackService/Status" => { 3160 3704 #[allow(non_camel_case_types)] 3161 3705 struct StatusSvc<T: PlaybackService>(pub Arc<T>); 3162 3162 - impl<T: PlaybackService> tonic::server::UnaryService<super::StatusRequest> for StatusSvc<T> { 3706 3706 + impl< 3707 3707 + T: PlaybackService, 3708 3708 + > tonic::server::UnaryService<super::StatusRequest> 3709 3709 + for StatusSvc<T> { 3163 3710 type Response = super::StatusResponse; 3164 3164 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3711 3711 + type Future = BoxFuture< 3712 3712 + tonic::Response<Self::Response>, 3713 3713 + tonic::Status, 3714 3714 + >; 3165 3715 fn call( 3166 3716 &mut self, 3167 3717 request: tonic::Request<super::StatusRequest>, ··· 3198 3748 "/rockbox.v1alpha1.PlaybackService/CurrentTrack" => { 3199 3749 #[allow(non_camel_case_types)] 3200 3750 struct CurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 3201 3201 - impl<T: PlaybackService> tonic::server::UnaryService<super::CurrentTrackRequest> 3202 3202 - for CurrentTrackSvc<T> 3203 3203 - { 3751 3751 + impl< 3752 3752 + T: PlaybackService, 3753 3753 + > tonic::server::UnaryService<super::CurrentTrackRequest> 3754 3754 + for CurrentTrackSvc<T> { 3204 3755 type Response = super::CurrentTrackResponse; 3205 3205 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3756 3756 + type Future = BoxFuture< 3757 3757 + tonic::Response<Self::Response>, 3758 3758 + tonic::Status, 3759 3759 + >; 3206 3760 fn call( 3207 3761 &mut self, 3208 3762 request: tonic::Request<super::CurrentTrackRequest>, ··· 3239 3793 "/rockbox.v1alpha1.PlaybackService/NextTrack" => { 3240 3794 #[allow(non_camel_case_types)] 3241 3795 struct NextTrackSvc<T: PlaybackService>(pub Arc<T>); 3242 3242 - impl<T: PlaybackService> tonic::server::UnaryService<super::NextTrackRequest> for NextTrackSvc<T> { 3796 3796 + impl< 3797 3797 + T: PlaybackService, 3798 3798 + > tonic::server::UnaryService<super::NextTrackRequest> 3799 3799 + for NextTrackSvc<T> { 3243 3800 type Response = super::NextTrackResponse; 3244 3244 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3801 3801 + type Future = BoxFuture< 3802 3802 + tonic::Response<Self::Response>, 3803 3803 + tonic::Status, 3804 3804 + >; 3245 3805 fn call( 3246 3806 &mut self, 3247 3807 request: tonic::Request<super::NextTrackRequest>, ··· 3278 3838 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks" => { 3279 3839 #[allow(non_camel_case_types)] 3280 3840 struct FlushAndReloadTracksSvc<T: PlaybackService>(pub Arc<T>); 3281 3281 - impl<T: PlaybackService> 3282 3282 - tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3283 3283 - for FlushAndReloadTracksSvc<T> 3284 3284 - { 3841 3841 + impl< 3842 3842 + T: PlaybackService, 3843 3843 + > tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3844 3844 + for FlushAndReloadTracksSvc<T> { 3285 3845 type Response = super::FlushAndReloadTracksResponse; 3286 3286 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3846 3846 + type Future = BoxFuture< 3847 3847 + tonic::Response<Self::Response>, 3848 3848 + tonic::Status, 3849 3849 + >; 3287 3850 fn call( 3288 3851 &mut self, 3289 3852 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3290 3853 ) -> Self::Future { 3291 3854 let inner = Arc::clone(&self.0); 3292 3855 let fut = async move { 3293 3293 - <T as PlaybackService>::flush_and_reload_tracks(&inner, request) 3856 3856 + <T as PlaybackService>::flush_and_reload_tracks( 3857 3857 + &inner, 3858 3858 + request, 3859 3859 + ) 3294 3860 .await 3295 3861 }; 3296 3862 Box::pin(fut) ··· 3321 3887 "/rockbox.v1alpha1.PlaybackService/GetFilePosition" => { 3322 3888 #[allow(non_camel_case_types)] 3323 3889 struct GetFilePositionSvc<T: PlaybackService>(pub Arc<T>); 3324 3324 - impl<T: PlaybackService> 3325 3325 - tonic::server::UnaryService<super::GetFilePositionRequest> 3326 3326 - for GetFilePositionSvc<T> 3327 3327 - { 3890 3890 + impl< 3891 3891 + T: PlaybackService, 3892 3892 + > tonic::server::UnaryService<super::GetFilePositionRequest> 3893 3893 + for GetFilePositionSvc<T> { 3328 3894 type Response = super::GetFilePositionResponse; 3329 3329 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3895 3895 + type Future = BoxFuture< 3896 3896 + tonic::Response<Self::Response>, 3897 3897 + tonic::Status, 3898 3898 + >; 3330 3899 fn call( 3331 3900 &mut self, 3332 3901 request: tonic::Request<super::GetFilePositionRequest>, 3333 3902 ) -> Self::Future { 3334 3903 let inner = Arc::clone(&self.0); 3335 3904 let fut = async move { 3336 3336 - <T as PlaybackService>::get_file_position(&inner, request).await 3905 3905 + <T as PlaybackService>::get_file_position(&inner, request) 3906 3906 + .await 3337 3907 }; 3338 3908 Box::pin(fut) 3339 3909 } ··· 3363 3933 "/rockbox.v1alpha1.PlaybackService/HardStop" => { 3364 3934 #[allow(non_camel_case_types)] 3365 3935 struct HardStopSvc<T: PlaybackService>(pub Arc<T>); 3366 3366 - impl<T: PlaybackService> tonic::server::UnaryService<super::HardStopRequest> for HardStopSvc<T> { 3936 3936 + impl< 3937 3937 + T: PlaybackService, 3938 3938 + > tonic::server::UnaryService<super::HardStopRequest> 3939 3939 + for HardStopSvc<T> { 3367 3940 type Response = super::HardStopResponse; 3368 3368 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3941 3941 + type Future = BoxFuture< 3942 3942 + tonic::Response<Self::Response>, 3943 3943 + tonic::Status, 3944 3944 + >; 3369 3945 fn call( 3370 3946 &mut self, 3371 3947 request: tonic::Request<super::HardStopRequest>, ··· 3402 3978 "/rockbox.v1alpha1.PlaybackService/PlayAlbum" => { 3403 3979 #[allow(non_camel_case_types)] 3404 3980 struct PlayAlbumSvc<T: PlaybackService>(pub Arc<T>); 3405 3405 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayAlbumRequest> for PlayAlbumSvc<T> { 3981 3981 + impl< 3982 3982 + T: PlaybackService, 3983 3983 + > tonic::server::UnaryService<super::PlayAlbumRequest> 3984 3984 + for PlayAlbumSvc<T> { 3406 3985 type Response = super::PlayAlbumResponse; 3407 3407 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3986 3986 + type Future = BoxFuture< 3987 3987 + tonic::Response<Self::Response>, 3988 3988 + tonic::Status, 3989 3989 + >; 3408 3990 fn call( 3409 3991 &mut self, 3410 3992 request: tonic::Request<super::PlayAlbumRequest>, ··· 3441 4023 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks" => { 3442 4024 #[allow(non_camel_case_types)] 3443 4025 struct PlayArtistTracksSvc<T: PlaybackService>(pub Arc<T>); 3444 3444 - impl<T: PlaybackService> 3445 3445 - tonic::server::UnaryService<super::PlayArtistTracksRequest> 3446 3446 - for PlayArtistTracksSvc<T> 3447 3447 - { 4026 4026 + impl< 4027 4027 + T: PlaybackService, 4028 4028 + > tonic::server::UnaryService<super::PlayArtistTracksRequest> 4029 4029 + for PlayArtistTracksSvc<T> { 3448 4030 type Response = super::PlayArtistTracksResponse; 3449 3449 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4031 4031 + type Future = BoxFuture< 4032 4032 + tonic::Response<Self::Response>, 4033 4033 + tonic::Status, 4034 4034 + >; 3450 4035 fn call( 3451 4036 &mut self, 3452 4037 request: tonic::Request<super::PlayArtistTracksRequest>, 3453 4038 ) -> Self::Future { 3454 4039 let inner = Arc::clone(&self.0); 3455 4040 let fut = async move { 3456 3456 - <T as PlaybackService>::play_artist_tracks(&inner, request).await 4041 4041 + <T as PlaybackService>::play_artist_tracks(&inner, request) 4042 4042 + .await 3457 4043 }; 3458 4044 Box::pin(fut) 3459 4045 } ··· 3483 4069 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist" => { 3484 4070 #[allow(non_camel_case_types)] 3485 4071 struct PlayPlaylistSvc<T: PlaybackService>(pub Arc<T>); 3486 3486 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayPlaylistRequest> 3487 3487 - for PlayPlaylistSvc<T> 3488 3488 - { 4072 4072 + impl< 4073 4073 + T: PlaybackService, 4074 4074 + > tonic::server::UnaryService<super::PlayPlaylistRequest> 4075 4075 + for PlayPlaylistSvc<T> { 3489 4076 type Response = super::PlayPlaylistResponse; 3490 3490 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4077 4077 + type Future = BoxFuture< 4078 4078 + tonic::Response<Self::Response>, 4079 4079 + tonic::Status, 4080 4080 + >; 3491 4081 fn call( 3492 4082 &mut self, 3493 4083 request: tonic::Request<super::PlayPlaylistRequest>, ··· 3524 4114 "/rockbox.v1alpha1.PlaybackService/PlayDirectory" => { 3525 4115 #[allow(non_camel_case_types)] 3526 4116 struct PlayDirectorySvc<T: PlaybackService>(pub Arc<T>); 3527 3527 - impl<T: PlaybackService> 3528 3528 - tonic::server::UnaryService<super::PlayDirectoryRequest> 3529 3529 - for PlayDirectorySvc<T> 3530 3530 - { 4117 4117 + impl< 4118 4118 + T: PlaybackService, 4119 4119 + > tonic::server::UnaryService<super::PlayDirectoryRequest> 4120 4120 + for PlayDirectorySvc<T> { 3531 4121 type Response = super::PlayDirectoryResponse; 3532 3532 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4122 4122 + type Future = BoxFuture< 4123 4123 + tonic::Response<Self::Response>, 4124 4124 + tonic::Status, 4125 4125 + >; 3533 4126 fn call( 3534 4127 &mut self, 3535 4128 request: tonic::Request<super::PlayDirectoryRequest>, 3536 4129 ) -> Self::Future { 3537 4130 let inner = Arc::clone(&self.0); 3538 4131 let fut = async move { 3539 3539 - <T as PlaybackService>::play_directory(&inner, request).await 4132 4132 + <T as PlaybackService>::play_directory(&inner, request) 4133 4133 + .await 3540 4134 }; 3541 4135 Box::pin(fut) 3542 4136 } ··· 3566 4160 "/rockbox.v1alpha1.PlaybackService/PlayMusicDirectory" => { 3567 4161 #[allow(non_camel_case_types)] 3568 4162 struct PlayMusicDirectorySvc<T: PlaybackService>(pub Arc<T>); 3569 3569 - impl<T: PlaybackService> 3570 3570 - tonic::server::UnaryService<super::PlayMusicDirectoryRequest> 3571 3571 - for PlayMusicDirectorySvc<T> 3572 3572 - { 4163 4163 + impl< 4164 4164 + T: PlaybackService, 4165 4165 + > tonic::server::UnaryService<super::PlayMusicDirectoryRequest> 4166 4166 + for PlayMusicDirectorySvc<T> { 3573 4167 type Response = super::PlayMusicDirectoryResponse; 3574 3574 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4168 4168 + type Future = BoxFuture< 4169 4169 + tonic::Response<Self::Response>, 4170 4170 + tonic::Status, 4171 4171 + >; 3575 4172 fn call( 3576 4173 &mut self, 3577 4174 request: tonic::Request<super::PlayMusicDirectoryRequest>, 3578 4175 ) -> Self::Future { 3579 4176 let inner = Arc::clone(&self.0); 3580 4177 let fut = async move { 3581 3581 - <T as PlaybackService>::play_music_directory(&inner, request).await 4178 4178 + <T as PlaybackService>::play_music_directory( 4179 4179 + &inner, 4180 4180 + request, 4181 4181 + ) 4182 4182 + .await 3582 4183 }; 3583 4184 Box::pin(fut) 3584 4185 } ··· 3608 4209 "/rockbox.v1alpha1.PlaybackService/PlayTrack" => { 3609 4210 #[allow(non_camel_case_types)] 3610 4211 struct PlayTrackSvc<T: PlaybackService>(pub Arc<T>); 3611 3611 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayTrackRequest> for PlayTrackSvc<T> { 4212 4212 + impl< 4213 4213 + T: PlaybackService, 4214 4214 + > tonic::server::UnaryService<super::PlayTrackRequest> 4215 4215 + for PlayTrackSvc<T> { 3612 4216 type Response = super::PlayTrackResponse; 3613 3613 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4217 4217 + type Future = BoxFuture< 4218 4218 + tonic::Response<Self::Response>, 4219 4219 + tonic::Status, 4220 4220 + >; 3614 4221 fn call( 3615 4222 &mut self, 3616 4223 request: tonic::Request<super::PlayTrackRequest>, ··· 3647 4254 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks" => { 3648 4255 #[allow(non_camel_case_types)] 3649 4256 struct PlayLikedTracksSvc<T: PlaybackService>(pub Arc<T>); 3650 3650 - impl<T: PlaybackService> 3651 3651 - tonic::server::UnaryService<super::PlayLikedTracksRequest> 3652 3652 - for PlayLikedTracksSvc<T> 3653 3653 - { 4257 4257 + impl< 4258 4258 + T: PlaybackService, 4259 4259 + > tonic::server::UnaryService<super::PlayLikedTracksRequest> 4260 4260 + for PlayLikedTracksSvc<T> { 3654 4261 type Response = super::PlayLikedTracksResponse; 3655 3655 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4262 4262 + type Future = BoxFuture< 4263 4263 + tonic::Response<Self::Response>, 4264 4264 + tonic::Status, 4265 4265 + >; 3656 4266 fn call( 3657 4267 &mut self, 3658 4268 request: tonic::Request<super::PlayLikedTracksRequest>, 3659 4269 ) -> Self::Future { 3660 4270 let inner = Arc::clone(&self.0); 3661 4271 let fut = async move { 3662 3662 - <T as PlaybackService>::play_liked_tracks(&inner, request).await 4272 4272 + <T as PlaybackService>::play_liked_tracks(&inner, request) 4273 4273 + .await 3663 4274 }; 3664 4275 Box::pin(fut) 3665 4276 } ··· 3689 4300 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks" => { 3690 4301 #[allow(non_camel_case_types)] 3691 4302 struct PlayAllTracksSvc<T: PlaybackService>(pub Arc<T>); 3692 3692 - impl<T: PlaybackService> 3693 3693 - tonic::server::UnaryService<super::PlayAllTracksRequest> 3694 3694 - for PlayAllTracksSvc<T> 3695 3695 - { 4303 4303 + impl< 4304 4304 + T: PlaybackService, 4305 4305 + > tonic::server::UnaryService<super::PlayAllTracksRequest> 4306 4306 + for PlayAllTracksSvc<T> { 3696 4307 type Response = super::PlayAllTracksResponse; 3697 3697 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4308 4308 + type Future = BoxFuture< 4309 4309 + tonic::Response<Self::Response>, 4310 4310 + tonic::Status, 4311 4311 + >; 3698 4312 fn call( 3699 4313 &mut self, 3700 4314 request: tonic::Request<super::PlayAllTracksRequest>, 3701 4315 ) -> Self::Future { 3702 4316 let inner = Arc::clone(&self.0); 3703 4317 let fut = async move { 3704 3704 - <T as PlaybackService>::play_all_tracks(&inner, request).await 4318 4318 + <T as PlaybackService>::play_all_tracks(&inner, request) 4319 4319 + .await 3705 4320 }; 3706 4321 Box::pin(fut) 3707 4322 } ··· 3731 4346 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack" => { 3732 4347 #[allow(non_camel_case_types)] 3733 4348 struct StreamCurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 3734 3734 - impl<T: PlaybackService> 3735 3735 - tonic::server::ServerStreamingService<super::StreamCurrentTrackRequest> 3736 3736 - for StreamCurrentTrackSvc<T> 3737 3737 - { 4349 4349 + impl< 4350 4350 + T: PlaybackService, 4351 4351 + > tonic::server::ServerStreamingService< 4352 4352 + super::StreamCurrentTrackRequest, 4353 4353 + > for StreamCurrentTrackSvc<T> { 3738 4354 type Response = super::CurrentTrackResponse; 3739 4355 type ResponseStream = T::StreamCurrentTrackStream; 3740 3740 - type Future = 3741 3741 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4356 4356 + type Future = BoxFuture< 4357 4357 + tonic::Response<Self::ResponseStream>, 4358 4358 + tonic::Status, 4359 4359 + >; 3742 4360 fn call( 3743 4361 &mut self, 3744 4362 request: tonic::Request<super::StreamCurrentTrackRequest>, 3745 4363 ) -> Self::Future { 3746 4364 let inner = Arc::clone(&self.0); 3747 4365 let fut = async move { 3748 3748 - <T as PlaybackService>::stream_current_track(&inner, request).await 4366 4366 + <T as PlaybackService>::stream_current_track( 4367 4367 + &inner, 4368 4368 + request, 4369 4369 + ) 4370 4370 + .await 3749 4371 }; 3750 4372 Box::pin(fut) 3751 4373 } ··· 3775 4397 "/rockbox.v1alpha1.PlaybackService/StreamStatus" => { 3776 4398 #[allow(non_camel_case_types)] 3777 4399 struct StreamStatusSvc<T: PlaybackService>(pub Arc<T>); 3778 3778 - impl<T: PlaybackService> 3779 3779 - tonic::server::ServerStreamingService<super::StreamStatusRequest> 3780 3780 - for StreamStatusSvc<T> 3781 3781 - { 4400 4400 + impl< 4401 4401 + T: PlaybackService, 4402 4402 + > tonic::server::ServerStreamingService<super::StreamStatusRequest> 4403 4403 + for StreamStatusSvc<T> { 3782 4404 type Response = super::StatusResponse; 3783 4405 type ResponseStream = T::StreamStatusStream; 3784 3784 - type Future = 3785 3785 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4406 4406 + type Future = BoxFuture< 4407 4407 + tonic::Response<Self::ResponseStream>, 4408 4408 + tonic::Status, 4409 4409 + >; 3786 4410 fn call( 3787 4411 &mut self, 3788 4412 request: tonic::Request<super::StreamStatusRequest>, ··· 3819 4443 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist" => { 3820 4444 #[allow(non_camel_case_types)] 3821 4445 struct StreamPlaylistSvc<T: PlaybackService>(pub Arc<T>); 3822 3822 - impl<T: PlaybackService> 3823 3823 - tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 3824 3824 - for StreamPlaylistSvc<T> 3825 3825 - { 4446 4446 + impl< 4447 4447 + T: PlaybackService, 4448 4448 + > tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 4449 4449 + for StreamPlaylistSvc<T> { 3826 4450 type Response = super::PlaylistResponse; 3827 4451 type ResponseStream = T::StreamPlaylistStream; 3828 3828 - type Future = 3829 3829 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4452 4452 + type Future = BoxFuture< 4453 4453 + tonic::Response<Self::ResponseStream>, 4454 4454 + tonic::Status, 4455 4455 + >; 3830 4456 fn call( 3831 4457 &mut self, 3832 4458 request: tonic::Request<super::StreamPlaylistRequest>, 3833 4459 ) -> Self::Future { 3834 4460 let inner = Arc::clone(&self.0); 3835 4461 let fut = async move { 3836 3836 - <T as PlaybackService>::stream_playlist(&inner, request).await 4462 4462 + <T as PlaybackService>::stream_playlist(&inner, request) 4463 4463 + .await 3837 4464 }; 3838 4465 Box::pin(fut) 3839 4466 } ··· 3860 4487 }; 3861 4488 Box::pin(fut) 3862 4489 } 3863 3863 - _ => Box::pin(async move { 3864 3864 - let mut response = http::Response::new(empty_body()); 3865 3865 - let headers = response.headers_mut(); 3866 3866 - headers.insert( 3867 3867 - tonic::Status::GRPC_STATUS, 3868 3868 - (tonic::Code::Unimplemented as i32).into(), 3869 3869 - ); 3870 3870 - headers.insert( 3871 3871 - http::header::CONTENT_TYPE, 3872 3872 - tonic::metadata::GRPC_CONTENT_TYPE, 3873 3873 - ); 3874 3874 - Ok(response) 3875 3875 - }), 4490 4490 + _ => { 4491 4491 + Box::pin(async move { 4492 4492 + let mut response = http::Response::new(empty_body()); 4493 4493 + let headers = response.headers_mut(); 4494 4494 + headers 4495 4495 + .insert( 4496 4496 + tonic::Status::GRPC_STATUS, 4497 4497 + (tonic::Code::Unimplemented as i32).into(), 4498 4498 + ); 4499 4499 + headers 4500 4500 + .insert( 4501 4501 + http::header::CONTENT_TYPE, 4502 4502 + tonic::metadata::GRPC_CONTENT_TYPE, 4503 4503 + ); 4504 4504 + Ok(response) 4505 4505 + }) 4506 4506 + } 3876 4507 } 3877 4508 } 3878 4509 } ··· 4079 4710 dead_code, 4080 4711 missing_docs, 4081 4712 clippy::wildcard_imports, 4082 4082 - clippy::let_unit_value 4713 4713 + clippy::let_unit_value, 4083 4714 )] 4084 4084 - use tonic::codegen::http::Uri; 4085 4715 use tonic::codegen::*; 4716 4716 + use tonic::codegen::http::Uri; 4086 4717 #[derive(Debug, Clone)] 4087 4718 pub struct PlaylistServiceClient<T> { 4088 4719 inner: tonic::client::Grpc<T>, ··· 4126 4757 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 4127 4758 >, 4128 4759 >, 4129 4129 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 4130 4130 - Into<StdError> + std::marker::Send + std::marker::Sync, 4760 4760 + <T as tonic::codegen::Service< 4761 4761 + http::Request<tonic::body::BoxBody>, 4762 4762 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 4131 4763 { 4132 4764 PlaylistServiceClient::new(InterceptedService::new(inner, interceptor)) 4133 4765 } ··· 4165 4797 pub async fn get_current( 4166 4798 &mut self, 4167 4799 request: impl tonic::IntoRequest<super::GetCurrentRequest>, 4168 4168 - ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status> 4169 4169 - { 4170 4170 - self.inner.ready().await.map_err(|e| { 4171 4171 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4172 4172 - })?; 4800 4800 + ) -> std::result::Result< 4801 4801 + tonic::Response<super::GetCurrentResponse>, 4802 4802 + tonic::Status, 4803 4803 + > { 4804 4804 + self.inner 4805 4805 + .ready() 4806 4806 + .await 4807 4807 + .map_err(|e| { 4808 4808 + tonic::Status::unknown( 4809 4809 + format!("Service was not ready: {}", e.into()), 4810 4810 + ) 4811 4811 + })?; 4173 4812 let codec = tonic::codec::ProstCodec::default(); 4174 4813 let path = http::uri::PathAndQuery::from_static( 4175 4814 "/rockbox.v1alpha1.PlaylistService/GetCurrent", 4176 4815 ); 4177 4816 let mut req = request.into_request(); 4178 4178 - req.extensions_mut().insert(GrpcMethod::new( 4179 4179 - "rockbox.v1alpha1.PlaylistService", 4180 4180 - "GetCurrent", 4181 4181 - )); 4817 4817 + req.extensions_mut() 4818 4818 + .insert( 4819 4819 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetCurrent"), 4820 4820 + ); 4182 4821 self.inner.unary(req, path, codec).await 4183 4822 } 4184 4823 pub async fn get_resume_info( 4185 4824 &mut self, 4186 4825 request: impl tonic::IntoRequest<super::GetResumeInfoRequest>, 4187 4187 - ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status> 4188 4188 - { 4189 4189 - self.inner.ready().await.map_err(|e| { 4190 4190 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4191 4191 - })?; 4826 4826 + ) -> std::result::Result< 4827 4827 + tonic::Response<super::GetResumeInfoResponse>, 4828 4828 + tonic::Status, 4829 4829 + > { 4830 4830 + self.inner 4831 4831 + .ready() 4832 4832 + .await 4833 4833 + .map_err(|e| { 4834 4834 + tonic::Status::unknown( 4835 4835 + format!("Service was not ready: {}", e.into()), 4836 4836 + ) 4837 4837 + })?; 4192 4838 let codec = tonic::codec::ProstCodec::default(); 4193 4839 let path = http::uri::PathAndQuery::from_static( 4194 4840 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo", 4195 4841 ); 4196 4842 let mut req = request.into_request(); 4197 4197 - req.extensions_mut().insert(GrpcMethod::new( 4198 4198 - "rockbox.v1alpha1.PlaylistService", 4199 4199 - "GetResumeInfo", 4200 4200 - )); 4843 4843 + req.extensions_mut() 4844 4844 + .insert( 4845 4845 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetResumeInfo"), 4846 4846 + ); 4201 4847 self.inner.unary(req, path, codec).await 4202 4848 } 4203 4849 pub async fn get_track_info( 4204 4850 &mut self, 4205 4851 request: impl tonic::IntoRequest<super::GetTrackInfoRequest>, 4206 4206 - ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status> 4207 4207 - { 4208 4208 - self.inner.ready().await.map_err(|e| { 4209 4209 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4210 4210 - })?; 4852 4852 + ) -> std::result::Result< 4853 4853 + tonic::Response<super::GetTrackInfoResponse>, 4854 4854 + tonic::Status, 4855 4855 + > { 4856 4856 + self.inner 4857 4857 + .ready() 4858 4858 + .await 4859 4859 + .map_err(|e| { 4860 4860 + tonic::Status::unknown( 4861 4861 + format!("Service was not ready: {}", e.into()), 4862 4862 + ) 4863 4863 + })?; 4211 4864 let codec = tonic::codec::ProstCodec::default(); 4212 4865 let path = http::uri::PathAndQuery::from_static( 4213 4866 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo", 4214 4867 ); 4215 4868 let mut req = request.into_request(); 4216 4216 - req.extensions_mut().insert(GrpcMethod::new( 4217 4217 - "rockbox.v1alpha1.PlaylistService", 4218 4218 - "GetTrackInfo", 4219 4219 - )); 4869 4869 + req.extensions_mut() 4870 4870 + .insert( 4871 4871 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetTrackInfo"), 4872 4872 + ); 4220 4873 self.inner.unary(req, path, codec).await 4221 4874 } 4222 4875 pub async fn get_first_index( 4223 4876 &mut self, 4224 4877 request: impl tonic::IntoRequest<super::GetFirstIndexRequest>, 4225 4225 - ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status> 4226 4226 - { 4227 4227 - self.inner.ready().await.map_err(|e| { 4228 4228 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4229 4229 - })?; 4878 4878 + ) -> std::result::Result< 4879 4879 + tonic::Response<super::GetFirstIndexResponse>, 4880 4880 + tonic::Status, 4881 4881 + > { 4882 4882 + self.inner 4883 4883 + .ready() 4884 4884 + .await 4885 4885 + .map_err(|e| { 4886 4886 + tonic::Status::unknown( 4887 4887 + format!("Service was not ready: {}", e.into()), 4888 4888 + ) 4889 4889 + })?; 4230 4890 let codec = tonic::codec::ProstCodec::default(); 4231 4891 let path = http::uri::PathAndQuery::from_static( 4232 4892 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex", 4233 4893 ); 4234 4894 let mut req = request.into_request(); 4235 4235 - req.extensions_mut().insert(GrpcMethod::new( 4236 4236 - "rockbox.v1alpha1.PlaylistService", 4237 4237 - "GetFirstIndex", 4238 4238 - )); 4895 4895 + req.extensions_mut() 4896 4896 + .insert( 4897 4897 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetFirstIndex"), 4898 4898 + ); 4239 4899 self.inner.unary(req, path, codec).await 4240 4900 } 4241 4901 pub async fn get_display_index( 4242 4902 &mut self, 4243 4903 request: impl tonic::IntoRequest<super::GetDisplayIndexRequest>, 4244 4244 - ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status> 4245 4245 - { 4246 4246 - self.inner.ready().await.map_err(|e| { 4247 4247 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4248 4248 - })?; 4904 4904 + ) -> std::result::Result< 4905 4905 + tonic::Response<super::GetDisplayIndexResponse>, 4906 4906 + tonic::Status, 4907 4907 + > { 4908 4908 + self.inner 4909 4909 + .ready() 4910 4910 + .await 4911 4911 + .map_err(|e| { 4912 4912 + tonic::Status::unknown( 4913 4913 + format!("Service was not ready: {}", e.into()), 4914 4914 + ) 4915 4915 + })?; 4249 4916 let codec = tonic::codec::ProstCodec::default(); 4250 4917 let path = http::uri::PathAndQuery::from_static( 4251 4918 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex", 4252 4919 ); 4253 4920 let mut req = request.into_request(); 4254 4254 - req.extensions_mut().insert(GrpcMethod::new( 4255 4255 - "rockbox.v1alpha1.PlaylistService", 4256 4256 - "GetDisplayIndex", 4257 4257 - )); 4921 4921 + req.extensions_mut() 4922 4922 + .insert( 4923 4923 + GrpcMethod::new( 4924 4924 + "rockbox.v1alpha1.PlaylistService", 4925 4925 + "GetDisplayIndex", 4926 4926 + ), 4927 4927 + ); 4258 4928 self.inner.unary(req, path, codec).await 4259 4929 } 4260 4930 pub async fn amount( 4261 4931 &mut self, 4262 4932 request: impl tonic::IntoRequest<super::AmountRequest>, 4263 4933 ) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status> { 4264 4264 - self.inner.ready().await.map_err(|e| { 4265 4265 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4266 4266 - })?; 4934 4934 + self.inner 4935 4935 + .ready() 4936 4936 + .await 4937 4937 + .map_err(|e| { 4938 4938 + tonic::Status::unknown( 4939 4939 + format!("Service was not ready: {}", e.into()), 4940 4940 + ) 4941 4941 + })?; 4267 4942 let codec = tonic::codec::ProstCodec::default(); 4268 4268 - let path = 4269 4269 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Amount"); 4943 4943 + let path = http::uri::PathAndQuery::from_static( 4944 4944 + "/rockbox.v1alpha1.PlaylistService/Amount", 4945 4945 + ); 4270 4946 let mut req = request.into_request(); 4271 4271 - req.extensions_mut().insert(GrpcMethod::new( 4272 4272 - "rockbox.v1alpha1.PlaylistService", 4273 4273 - "Amount", 4274 4274 - )); 4947 4947 + req.extensions_mut() 4948 4948 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Amount")); 4275 4949 self.inner.unary(req, path, codec).await 4276 4950 } 4277 4951 pub async fn playlist_resume( 4278 4952 &mut self, 4279 4953 request: impl tonic::IntoRequest<super::PlaylistResumeRequest>, 4280 4280 - ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status> 4281 4281 - { 4282 4282 - self.inner.ready().await.map_err(|e| { 4283 4283 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4284 4284 - })?; 4954 4954 + ) -> std::result::Result< 4955 4955 + tonic::Response<super::PlaylistResumeResponse>, 4956 4956 + tonic::Status, 4957 4957 + > { 4958 4958 + self.inner 4959 4959 + .ready() 4960 4960 + .await 4961 4961 + .map_err(|e| { 4962 4962 + tonic::Status::unknown( 4963 4963 + format!("Service was not ready: {}", e.into()), 4964 4964 + ) 4965 4965 + })?; 4285 4966 let codec = tonic::codec::ProstCodec::default(); 4286 4967 let path = http::uri::PathAndQuery::from_static( 4287 4968 "/rockbox.v1alpha1.PlaylistService/PlaylistResume", 4288 4969 ); 4289 4970 let mut req = request.into_request(); 4290 4290 - req.extensions_mut().insert(GrpcMethod::new( 4291 4291 - "rockbox.v1alpha1.PlaylistService", 4292 4292 - "PlaylistResume", 4293 4293 - )); 4971 4971 + req.extensions_mut() 4972 4972 + .insert( 4973 4973 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "PlaylistResume"), 4974 4974 + ); 4294 4975 self.inner.unary(req, path, codec).await 4295 4976 } 4296 4977 pub async fn resume_track( 4297 4978 &mut self, 4298 4979 request: impl tonic::IntoRequest<super::ResumeTrackRequest>, 4299 4299 - ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status> 4300 4300 - { 4301 4301 - self.inner.ready().await.map_err(|e| { 4302 4302 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4303 4303 - })?; 4980 4980 + ) -> std::result::Result< 4981 4981 + tonic::Response<super::ResumeTrackResponse>, 4982 4982 + tonic::Status, 4983 4983 + > { 4984 4984 + self.inner 4985 4985 + .ready() 4986 4986 + .await 4987 4987 + .map_err(|e| { 4988 4988 + tonic::Status::unknown( 4989 4989 + format!("Service was not ready: {}", e.into()), 4990 4990 + ) 4991 4991 + })?; 4304 4992 let codec = tonic::codec::ProstCodec::default(); 4305 4993 let path = http::uri::PathAndQuery::from_static( 4306 4994 "/rockbox.v1alpha1.PlaylistService/ResumeTrack", 4307 4995 ); 4308 4996 let mut req = request.into_request(); 4309 4309 - req.extensions_mut().insert(GrpcMethod::new( 4310 4310 - "rockbox.v1alpha1.PlaylistService", 4311 4311 - "ResumeTrack", 4312 4312 - )); 4997 4997 + req.extensions_mut() 4998 4998 + .insert( 4999 4999 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "ResumeTrack"), 5000 5000 + ); 4313 5001 self.inner.unary(req, path, codec).await 4314 5002 } 4315 5003 pub async fn set_modified( 4316 5004 &mut self, 4317 5005 request: impl tonic::IntoRequest<super::SetModifiedRequest>, 4318 4318 - ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status> 4319 4319 - { 4320 4320 - self.inner.ready().await.map_err(|e| { 4321 4321 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4322 4322 - })?; 5006 5006 + ) -> std::result::Result< 5007 5007 + tonic::Response<super::SetModifiedResponse>, 5008 5008 + tonic::Status, 5009 5009 + > { 5010 5010 + self.inner 5011 5011 + .ready() 5012 5012 + .await 5013 5013 + .map_err(|e| { 5014 5014 + tonic::Status::unknown( 5015 5015 + format!("Service was not ready: {}", e.into()), 5016 5016 + ) 5017 5017 + })?; 4323 5018 let codec = tonic::codec::ProstCodec::default(); 4324 5019 let path = http::uri::PathAndQuery::from_static( 4325 5020 "/rockbox.v1alpha1.PlaylistService/SetModified", 4326 5021 ); 4327 5022 let mut req = request.into_request(); 4328 4328 - req.extensions_mut().insert(GrpcMethod::new( 4329 4329 - "rockbox.v1alpha1.PlaylistService", 4330 4330 - "SetModified", 4331 4331 - )); 5023 5023 + req.extensions_mut() 5024 5024 + .insert( 5025 5025 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "SetModified"), 5026 5026 + ); 4332 5027 self.inner.unary(req, path, codec).await 4333 5028 } 4334 5029 pub async fn start( 4335 5030 &mut self, 4336 5031 request: impl tonic::IntoRequest<super::StartRequest>, 4337 5032 ) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status> { 4338 4338 - self.inner.ready().await.map_err(|e| { 4339 4339 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4340 4340 - })?; 5033 5033 + self.inner 5034 5034 + .ready() 5035 5035 + .await 5036 5036 + .map_err(|e| { 5037 5037 + tonic::Status::unknown( 5038 5038 + format!("Service was not ready: {}", e.into()), 5039 5039 + ) 5040 5040 + })?; 4341 5041 let codec = tonic::codec::ProstCodec::default(); 4342 4342 - let path = 4343 4343 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Start"); 5042 5042 + let path = http::uri::PathAndQuery::from_static( 5043 5043 + "/rockbox.v1alpha1.PlaylistService/Start", 5044 5044 + ); 4344 5045 let mut req = request.into_request(); 4345 5046 req.extensions_mut() 4346 5047 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Start")); ··· 4350 5051 &mut self, 4351 5052 request: impl tonic::IntoRequest<super::SyncRequest>, 4352 5053 ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> { 4353 4353 - self.inner.ready().await.map_err(|e| { 4354 4354 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4355 4355 - })?; 5054 5054 + self.inner 5055 5055 + .ready() 5056 5056 + .await 5057 5057 + .map_err(|e| { 5058 5058 + tonic::Status::unknown( 5059 5059 + format!("Service was not ready: {}", e.into()), 5060 5060 + ) 5061 5061 + })?; 4356 5062 let codec = tonic::codec::ProstCodec::default(); 4357 4357 - let path = 4358 4358 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Sync"); 5063 5063 + let path = http::uri::PathAndQuery::from_static( 5064 5064 + "/rockbox.v1alpha1.PlaylistService/Sync", 5065 5065 + ); 4359 5066 let mut req = request.into_request(); 4360 5067 req.extensions_mut() 4361 5068 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Sync")); ··· 4364 5071 pub async fn remove_all_tracks( 4365 5072 &mut self, 4366 5073 request: impl tonic::IntoRequest<super::RemoveAllTracksRequest>, 4367 4367 - ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status> 4368 4368 - { 4369 4369 - self.inner.ready().await.map_err(|e| { 4370 4370 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4371 4371 - })?; 5074 5074 + ) -> std::result::Result< 5075 5075 + tonic::Response<super::RemoveAllTracksResponse>, 5076 5076 + tonic::Status, 5077 5077 + > { 5078 5078 + self.inner 5079 5079 + .ready() 5080 5080 + .await 5081 5081 + .map_err(|e| { 5082 5082 + tonic::Status::unknown( 5083 5083 + format!("Service was not ready: {}", e.into()), 5084 5084 + ) 5085 5085 + })?; 4372 5086 let codec = tonic::codec::ProstCodec::default(); 4373 5087 let path = http::uri::PathAndQuery::from_static( 4374 5088 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks", 4375 5089 ); 4376 5090 let mut req = request.into_request(); 4377 4377 - req.extensions_mut().insert(GrpcMethod::new( 4378 4378 - "rockbox.v1alpha1.PlaylistService", 4379 4379 - "RemoveAllTracks", 4380 4380 - )); 5091 5091 + req.extensions_mut() 5092 5092 + .insert( 5093 5093 + GrpcMethod::new( 5094 5094 + "rockbox.v1alpha1.PlaylistService", 5095 5095 + "RemoveAllTracks", 5096 5096 + ), 5097 5097 + ); 4381 5098 self.inner.unary(req, path, codec).await 4382 5099 } 4383 5100 pub async fn remove_tracks( 4384 5101 &mut self, 4385 5102 request: impl tonic::IntoRequest<super::RemoveTracksRequest>, 4386 4386 - ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status> 4387 4387 - { 4388 4388 - self.inner.ready().await.map_err(|e| { 4389 4389 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4390 4390 - })?; 5103 5103 + ) -> std::result::Result< 5104 5104 + tonic::Response<super::RemoveTracksResponse>, 5105 5105 + tonic::Status, 5106 5106 + > { 5107 5107 + self.inner 5108 5108 + .ready() 5109 5109 + .await 5110 5110 + .map_err(|e| { 5111 5111 + tonic::Status::unknown( 5112 5112 + format!("Service was not ready: {}", e.into()), 5113 5113 + ) 5114 5114 + })?; 4391 5115 let codec = tonic::codec::ProstCodec::default(); 4392 5116 let path = http::uri::PathAndQuery::from_static( 4393 5117 "/rockbox.v1alpha1.PlaylistService/RemoveTracks", 4394 5118 ); 4395 5119 let mut req = request.into_request(); 4396 4396 - req.extensions_mut().insert(GrpcMethod::new( 4397 4397 - "rockbox.v1alpha1.PlaylistService", 4398 4398 - "RemoveTracks", 4399 4399 - )); 5120 5120 + req.extensions_mut() 5121 5121 + .insert( 5122 5122 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "RemoveTracks"), 5123 5123 + ); 4400 5124 self.inner.unary(req, path, codec).await 4401 5125 } 4402 5126 pub async fn create_playlist( 4403 5127 &mut self, 4404 5128 request: impl tonic::IntoRequest<super::CreatePlaylistRequest>, 4405 4405 - ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status> 4406 4406 - { 4407 4407 - self.inner.ready().await.map_err(|e| { 4408 4408 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4409 4409 - })?; 5129 5129 + ) -> std::result::Result< 5130 5130 + tonic::Response<super::CreatePlaylistResponse>, 5131 5131 + tonic::Status, 5132 5132 + > { 5133 5133 + self.inner 5134 5134 + .ready() 5135 5135 + .await 5136 5136 + .map_err(|e| { 5137 5137 + tonic::Status::unknown( 5138 5138 + format!("Service was not ready: {}", e.into()), 5139 5139 + ) 5140 5140 + })?; 4410 5141 let codec = tonic::codec::ProstCodec::default(); 4411 5142 let path = http::uri::PathAndQuery::from_static( 4412 5143 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist", 4413 5144 ); 4414 5145 let mut req = request.into_request(); 4415 4415 - req.extensions_mut().insert(GrpcMethod::new( 4416 4416 - "rockbox.v1alpha1.PlaylistService", 4417 4417 - "CreatePlaylist", 4418 4418 - )); 5146 5146 + req.extensions_mut() 5147 5147 + .insert( 5148 5148 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "CreatePlaylist"), 5149 5149 + ); 4419 5150 self.inner.unary(req, path, codec).await 4420 5151 } 4421 5152 pub async fn insert_tracks( 4422 5153 &mut self, 4423 5154 request: impl tonic::IntoRequest<super::InsertTracksRequest>, 4424 4424 - ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status> 4425 4425 - { 4426 4426 - self.inner.ready().await.map_err(|e| { 4427 4427 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4428 4428 - })?; 5155 5155 + ) -> std::result::Result< 5156 5156 + tonic::Response<super::InsertTracksResponse>, 5157 5157 + tonic::Status, 5158 5158 + > { 5159 5159 + self.inner 5160 5160 + .ready() 5161 5161 + .await 5162 5162 + .map_err(|e| { 5163 5163 + tonic::Status::unknown( 5164 5164 + format!("Service was not ready: {}", e.into()), 5165 5165 + ) 5166 5166 + })?; 4429 5167 let codec = tonic::codec::ProstCodec::default(); 4430 5168 let path = http::uri::PathAndQuery::from_static( 4431 5169 "/rockbox.v1alpha1.PlaylistService/InsertTracks", 4432 5170 ); 4433 5171 let mut req = request.into_request(); 4434 4434 - req.extensions_mut().insert(GrpcMethod::new( 4435 4435 - "rockbox.v1alpha1.PlaylistService", 4436 4436 - "InsertTracks", 4437 4437 - )); 5172 5172 + req.extensions_mut() 5173 5173 + .insert( 5174 5174 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertTracks"), 5175 5175 + ); 4438 5176 self.inner.unary(req, path, codec).await 4439 5177 } 4440 5178 pub async fn insert_directory( 4441 5179 &mut self, 4442 5180 request: impl tonic::IntoRequest<super::InsertDirectoryRequest>, 4443 4443 - ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status> 4444 4444 - { 4445 4445 - self.inner.ready().await.map_err(|e| { 4446 4446 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4447 4447 - })?; 5181 5181 + ) -> std::result::Result< 5182 5182 + tonic::Response<super::InsertDirectoryResponse>, 5183 5183 + tonic::Status, 5184 5184 + > { 5185 5185 + self.inner 5186 5186 + .ready() 5187 5187 + .await 5188 5188 + .map_err(|e| { 5189 5189 + tonic::Status::unknown( 5190 5190 + format!("Service was not ready: {}", e.into()), 5191 5191 + ) 5192 5192 + })?; 4448 5193 let codec = tonic::codec::ProstCodec::default(); 4449 5194 let path = http::uri::PathAndQuery::from_static( 4450 5195 "/rockbox.v1alpha1.PlaylistService/InsertDirectory", 4451 5196 ); 4452 5197 let mut req = request.into_request(); 4453 4453 - req.extensions_mut().insert(GrpcMethod::new( 4454 4454 - "rockbox.v1alpha1.PlaylistService", 4455 4455 - "InsertDirectory", 4456 4456 - )); 5198 5198 + req.extensions_mut() 5199 5199 + .insert( 5200 5200 + GrpcMethod::new( 5201 5201 + "rockbox.v1alpha1.PlaylistService", 5202 5202 + "InsertDirectory", 5203 5203 + ), 5204 5204 + ); 4457 5205 self.inner.unary(req, path, codec).await 4458 5206 } 4459 5207 pub async fn insert_playlist( 4460 5208 &mut self, 4461 5209 request: impl tonic::IntoRequest<super::InsertPlaylistRequest>, 4462 4462 - ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status> 4463 4463 - { 4464 4464 - self.inner.ready().await.map_err(|e| { 4465 4465 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4466 4466 - })?; 5210 5210 + ) -> std::result::Result< 5211 5211 + tonic::Response<super::InsertPlaylistResponse>, 5212 5212 + tonic::Status, 5213 5213 + > { 5214 5214 + self.inner 5215 5215 + .ready() 5216 5216 + .await 5217 5217 + .map_err(|e| { 5218 5218 + tonic::Status::unknown( 5219 5219 + format!("Service was not ready: {}", e.into()), 5220 5220 + ) 5221 5221 + })?; 4467 5222 let codec = tonic::codec::ProstCodec::default(); 4468 5223 let path = http::uri::PathAndQuery::from_static( 4469 5224 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist", 4470 5225 ); 4471 5226 let mut req = request.into_request(); 4472 4472 - req.extensions_mut().insert(GrpcMethod::new( 4473 4473 - "rockbox.v1alpha1.PlaylistService", 4474 4474 - "InsertPlaylist", 4475 4475 - )); 5227 5227 + req.extensions_mut() 5228 5228 + .insert( 5229 5229 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertPlaylist"), 5230 5230 + ); 4476 5231 self.inner.unary(req, path, codec).await 4477 5232 } 4478 5233 pub async fn insert_album( 4479 5234 &mut self, 4480 5235 request: impl tonic::IntoRequest<super::InsertAlbumRequest>, 4481 4481 - ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status> 4482 4482 - { 4483 4483 - self.inner.ready().await.map_err(|e| { 4484 4484 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4485 4485 - })?; 5236 5236 + ) -> std::result::Result< 5237 5237 + tonic::Response<super::InsertAlbumResponse>, 5238 5238 + tonic::Status, 5239 5239 + > { 5240 5240 + self.inner 5241 5241 + .ready() 5242 5242 + .await 5243 5243 + .map_err(|e| { 5244 5244 + tonic::Status::unknown( 5245 5245 + format!("Service was not ready: {}", e.into()), 5246 5246 + ) 5247 5247 + })?; 4486 5248 let codec = tonic::codec::ProstCodec::default(); 4487 5249 let path = http::uri::PathAndQuery::from_static( 4488 5250 "/rockbox.v1alpha1.PlaylistService/InsertAlbum", 4489 5251 ); 4490 5252 let mut req = request.into_request(); 4491 4491 - req.extensions_mut().insert(GrpcMethod::new( 4492 4492 - "rockbox.v1alpha1.PlaylistService", 4493 4493 - "InsertAlbum", 4494 4494 - )); 5253 5253 + req.extensions_mut() 5254 5254 + .insert( 5255 5255 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertAlbum"), 5256 5256 + ); 4495 5257 self.inner.unary(req, path, codec).await 4496 5258 } 4497 5259 pub async fn insert_artist_tracks( 4498 5260 &mut self, 4499 5261 request: impl tonic::IntoRequest<super::InsertArtistTracksRequest>, 4500 4500 - ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status> 4501 4501 - { 4502 4502 - self.inner.ready().await.map_err(|e| { 4503 4503 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4504 4504 - })?; 5262 5262 + ) -> std::result::Result< 5263 5263 + tonic::Response<super::InsertArtistTracksResponse>, 5264 5264 + tonic::Status, 5265 5265 + > { 5266 5266 + self.inner 5267 5267 + .ready() 5268 5268 + .await 5269 5269 + .map_err(|e| { 5270 5270 + tonic::Status::unknown( 5271 5271 + format!("Service was not ready: {}", e.into()), 5272 5272 + ) 5273 5273 + })?; 4505 5274 let codec = tonic::codec::ProstCodec::default(); 4506 5275 let path = http::uri::PathAndQuery::from_static( 4507 5276 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks", 4508 5277 ); 4509 5278 let mut req = request.into_request(); 4510 4510 - req.extensions_mut().insert(GrpcMethod::new( 4511 4511 - "rockbox.v1alpha1.PlaylistService", 4512 4512 - "InsertArtistTracks", 4513 4513 - )); 5279 5279 + req.extensions_mut() 5280 5280 + .insert( 5281 5281 + GrpcMethod::new( 5282 5282 + "rockbox.v1alpha1.PlaylistService", 5283 5283 + "InsertArtistTracks", 5284 5284 + ), 5285 5285 + ); 4514 5286 self.inner.unary(req, path, codec).await 4515 5287 } 4516 5288 pub async fn shuffle_playlist( 4517 5289 &mut self, 4518 5290 request: impl tonic::IntoRequest<super::ShufflePlaylistRequest>, 4519 4519 - ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status> 4520 4520 - { 4521 4521 - self.inner.ready().await.map_err(|e| { 4522 4522 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4523 4523 - })?; 5291 5291 + ) -> std::result::Result< 5292 5292 + tonic::Response<super::ShufflePlaylistResponse>, 5293 5293 + tonic::Status, 5294 5294 + > { 5295 5295 + self.inner 5296 5296 + .ready() 5297 5297 + .await 5298 5298 + .map_err(|e| { 5299 5299 + tonic::Status::unknown( 5300 5300 + format!("Service was not ready: {}", e.into()), 5301 5301 + ) 5302 5302 + })?; 4524 5303 let codec = tonic::codec::ProstCodec::default(); 4525 5304 let path = http::uri::PathAndQuery::from_static( 4526 5305 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist", 4527 5306 ); 4528 5307 let mut req = request.into_request(); 4529 4529 - req.extensions_mut().insert(GrpcMethod::new( 4530 4530 - "rockbox.v1alpha1.PlaylistService", 4531 4531 - "ShufflePlaylist", 4532 4532 - )); 5308 5308 + req.extensions_mut() 5309 5309 + .insert( 5310 5310 + GrpcMethod::new( 5311 5311 + "rockbox.v1alpha1.PlaylistService", 5312 5312 + "ShufflePlaylist", 5313 5313 + ), 5314 5314 + ); 4533 5315 self.inner.unary(req, path, codec).await 4534 5316 } 4535 5317 } ··· 4541 5323 dead_code, 4542 5324 missing_docs, 4543 5325 clippy::wildcard_imports, 4544 4544 - clippy::let_unit_value 5326 5326 + clippy::let_unit_value, 4545 5327 )] 4546 5328 use tonic::codegen::*; 4547 5329 /// Generated trait containing gRPC methods that should be implemented for use with PlaylistServiceServer. ··· 4550 5332 async fn get_current( 4551 5333 &self, 4552 5334 request: tonic::Request<super::GetCurrentRequest>, 4553 4553 - ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status>; 5335 5335 + ) -> std::result::Result< 5336 5336 + tonic::Response<super::GetCurrentResponse>, 5337 5337 + tonic::Status, 5338 5338 + >; 4554 5339 async fn get_resume_info( 4555 5340 &self, 4556 5341 request: tonic::Request<super::GetResumeInfoRequest>, 4557 4557 - ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status>; 5342 5342 + ) -> std::result::Result< 5343 5343 + tonic::Response<super::GetResumeInfoResponse>, 5344 5344 + tonic::Status, 5345 5345 + >; 4558 5346 async fn get_track_info( 4559 5347 &self, 4560 5348 request: tonic::Request<super::GetTrackInfoRequest>, 4561 4561 - ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status>; 5349 5349 + ) -> std::result::Result< 5350 5350 + tonic::Response<super::GetTrackInfoResponse>, 5351 5351 + tonic::Status, 5352 5352 + >; 4562 5353 async fn get_first_index( 4563 5354 &self, 4564 5355 request: tonic::Request<super::GetFirstIndexRequest>, 4565 4565 - ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status>; 5356 5356 + ) -> std::result::Result< 5357 5357 + tonic::Response<super::GetFirstIndexResponse>, 5358 5358 + tonic::Status, 5359 5359 + >; 4566 5360 async fn get_display_index( 4567 5361 &self, 4568 5362 request: tonic::Request<super::GetDisplayIndexRequest>, 4569 4569 - ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>; 5363 5363 + ) -> std::result::Result< 5364 5364 + tonic::Response<super::GetDisplayIndexResponse>, 5365 5365 + tonic::Status, 5366 5366 + >; 4570 5367 async fn amount( 4571 5368 &self, 4572 5369 request: tonic::Request<super::AmountRequest>, ··· 4574 5371 async fn playlist_resume( 4575 5372 &self, 4576 5373 request: tonic::Request<super::PlaylistResumeRequest>, 4577 4577 - ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status>; 5374 5374 + ) -> std::result::Result< 5375 5375 + tonic::Response<super::PlaylistResumeResponse>, 5376 5376 + tonic::Status, 5377 5377 + >; 4578 5378 async fn resume_track( 4579 5379 &self, 4580 5380 request: tonic::Request<super::ResumeTrackRequest>, 4581 4581 - ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status>; 5381 5381 + ) -> std::result::Result< 5382 5382 + tonic::Response<super::ResumeTrackResponse>, 5383 5383 + tonic::Status, 5384 5384 + >; 4582 5385 async fn set_modified( 4583 5386 &self, 4584 5387 request: tonic::Request<super::SetModifiedRequest>, 4585 4585 - ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>; 5388 5388 + ) -> std::result::Result< 5389 5389 + tonic::Response<super::SetModifiedResponse>, 5390 5390 + tonic::Status, 5391 5391 + >; 4586 5392 async fn start( 4587 5393 &self, 4588 5394 request: tonic::Request<super::StartRequest>, ··· 4594 5400 async fn remove_all_tracks( 4595 5401 &self, 4596 5402 request: tonic::Request<super::RemoveAllTracksRequest>, 4597 4597 - ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status>; 5403 5403 + ) -> std::result::Result< 5404 5404 + tonic::Response<super::RemoveAllTracksResponse>, 5405 5405 + tonic::Status, 5406 5406 + >; 4598 5407 async fn remove_tracks( 4599 5408 &self, 4600 5409 request: tonic::Request<super::RemoveTracksRequest>, 4601 4601 - ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status>; 5410 5410 + ) -> std::result::Result< 5411 5411 + tonic::Response<super::RemoveTracksResponse>, 5412 5412 + tonic::Status, 5413 5413 + >; 4602 5414 async fn create_playlist( 4603 5415 &self, 4604 5416 request: tonic::Request<super::CreatePlaylistRequest>, 4605 4605 - ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status>; 5417 5417 + ) -> std::result::Result< 5418 5418 + tonic::Response<super::CreatePlaylistResponse>, 5419 5419 + tonic::Status, 5420 5420 + >; 4606 5421 async fn insert_tracks( 4607 5422 &self, 4608 5423 request: tonic::Request<super::InsertTracksRequest>, 4609 4609 - ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status>; 5424 5424 + ) -> std::result::Result< 5425 5425 + tonic::Response<super::InsertTracksResponse>, 5426 5426 + tonic::Status, 5427 5427 + >; 4610 5428 async fn insert_directory( 4611 5429 &self, 4612 5430 request: tonic::Request<super::InsertDirectoryRequest>, 4613 4613 - ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status>; 5431 5431 + ) -> std::result::Result< 5432 5432 + tonic::Response<super::InsertDirectoryResponse>, 5433 5433 + tonic::Status, 5434 5434 + >; 4614 5435 async fn insert_playlist( 4615 5436 &self, 4616 5437 request: tonic::Request<super::InsertPlaylistRequest>, 4617 4617 - ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status>; 5438 5438 + ) -> std::result::Result< 5439 5439 + tonic::Response<super::InsertPlaylistResponse>, 5440 5440 + tonic::Status, 5441 5441 + >; 4618 5442 async fn insert_album( 4619 5443 &self, 4620 5444 request: tonic::Request<super::InsertAlbumRequest>, 4621 4621 - ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>; 5445 5445 + ) -> std::result::Result< 5446 5446 + tonic::Response<super::InsertAlbumResponse>, 5447 5447 + tonic::Status, 5448 5448 + >; 4622 5449 async fn insert_artist_tracks( 4623 5450 &self, 4624 5451 request: tonic::Request<super::InsertArtistTracksRequest>, 4625 4625 - ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>; 5452 5452 + ) -> std::result::Result< 5453 5453 + tonic::Response<super::InsertArtistTracksResponse>, 5454 5454 + tonic::Status, 5455 5455 + >; 4626 5456 async fn shuffle_playlist( 4627 5457 &self, 4628 5458 request: tonic::Request<super::ShufflePlaylistRequest>, 4629 4629 - ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>; 5459 5459 + ) -> std::result::Result< 5460 5460 + tonic::Response<super::ShufflePlaylistResponse>, 5461 5461 + tonic::Status, 5462 5462 + >; 4630 5463 } 4631 5464 #[derive(Debug)] 4632 5465 pub struct PlaylistServiceServer<T> { ··· 4649 5482 max_encoding_message_size: None, 4650 5483 } 4651 5484 } 4652 4652 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 5485 5485 + pub fn with_interceptor<F>( 5486 5486 + inner: T, 5487 5487 + interceptor: F, 5488 5488 + ) -> InterceptedService<Self, F> 4653 5489 where 4654 5490 F: tonic::service::Interceptor, 4655 5491 { ··· 4704 5540 "/rockbox.v1alpha1.PlaylistService/GetCurrent" => { 4705 5541 #[allow(non_camel_case_types)] 4706 5542 struct GetCurrentSvc<T: PlaylistService>(pub Arc<T>); 4707 4707 - impl<T: PlaylistService> tonic::server::UnaryService<super::GetCurrentRequest> 4708 4708 - for GetCurrentSvc<T> 4709 4709 - { 5543 5543 + impl< 5544 5544 + T: PlaylistService, 5545 5545 + > tonic::server::UnaryService<super::GetCurrentRequest> 5546 5546 + for GetCurrentSvc<T> { 4710 5547 type Response = super::GetCurrentResponse; 4711 4711 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5548 5548 + type Future = BoxFuture< 5549 5549 + tonic::Response<Self::Response>, 5550 5550 + tonic::Status, 5551 5551 + >; 4712 5552 fn call( 4713 5553 &mut self, 4714 5554 request: tonic::Request<super::GetCurrentRequest>, ··· 4745 5585 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo" => { 4746 5586 #[allow(non_camel_case_types)] 4747 5587 struct GetResumeInfoSvc<T: PlaylistService>(pub Arc<T>); 4748 4748 - impl<T: PlaylistService> 4749 4749 - tonic::server::UnaryService<super::GetResumeInfoRequest> 4750 4750 - for GetResumeInfoSvc<T> 4751 4751 - { 5588 5588 + impl< 5589 5589 + T: PlaylistService, 5590 5590 + > tonic::server::UnaryService<super::GetResumeInfoRequest> 5591 5591 + for GetResumeInfoSvc<T> { 4752 5592 type Response = super::GetResumeInfoResponse; 4753 4753 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5593 5593 + type Future = BoxFuture< 5594 5594 + tonic::Response<Self::Response>, 5595 5595 + tonic::Status, 5596 5596 + >; 4754 5597 fn call( 4755 5598 &mut self, 4756 5599 request: tonic::Request<super::GetResumeInfoRequest>, 4757 5600 ) -> Self::Future { 4758 5601 let inner = Arc::clone(&self.0); 4759 5602 let fut = async move { 4760 4760 - <T as PlaylistService>::get_resume_info(&inner, request).await 5603 5603 + <T as PlaylistService>::get_resume_info(&inner, request) 5604 5604 + .await 4761 5605 }; 4762 5606 Box::pin(fut) 4763 5607 } ··· 4787 5631 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo" => { 4788 5632 #[allow(non_camel_case_types)] 4789 5633 struct GetTrackInfoSvc<T: PlaylistService>(pub Arc<T>); 4790 4790 - impl<T: PlaylistService> tonic::server::UnaryService<super::GetTrackInfoRequest> 4791 4791 - for GetTrackInfoSvc<T> 4792 4792 - { 5634 5634 + impl< 5635 5635 + T: PlaylistService, 5636 5636 + > tonic::server::UnaryService<super::GetTrackInfoRequest> 5637 5637 + for GetTrackInfoSvc<T> { 4793 5638 type Response = super::GetTrackInfoResponse; 4794 4794 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5639 5639 + type Future = BoxFuture< 5640 5640 + tonic::Response<Self::Response>, 5641 5641 + tonic::Status, 5642 5642 + >; 4795 5643 fn call( 4796 5644 &mut self, 4797 5645 request: tonic::Request<super::GetTrackInfoRequest>, 4798 5646 ) -> Self::Future { 4799 5647 let inner = Arc::clone(&self.0); 4800 5648 let fut = async move { 4801 4801 - <T as PlaylistService>::get_track_info(&inner, request).await 5649 5649 + <T as PlaylistService>::get_track_info(&inner, request) 5650 5650 + .await 4802 5651 }; 4803 5652 Box::pin(fut) 4804 5653 } ··· 4828 5677 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex" => { 4829 5678 #[allow(non_camel_case_types)] 4830 5679 struct GetFirstIndexSvc<T: PlaylistService>(pub Arc<T>); 4831 4831 - impl<T: PlaylistService> 4832 4832 - tonic::server::UnaryService<super::GetFirstIndexRequest> 4833 4833 - for GetFirstIndexSvc<T> 4834 4834 - { 5680 5680 + impl< 5681 5681 + T: PlaylistService, 5682 5682 + > tonic::server::UnaryService<super::GetFirstIndexRequest> 5683 5683 + for GetFirstIndexSvc<T> { 4835 5684 type Response = super::GetFirstIndexResponse; 4836 4836 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5685 5685 + type Future = BoxFuture< 5686 5686 + tonic::Response<Self::Response>, 5687 5687 + tonic::Status, 5688 5688 + >; 4837 5689 fn call( 4838 5690 &mut self, 4839 5691 request: tonic::Request<super::GetFirstIndexRequest>, 4840 5692 ) -> Self::Future { 4841 5693 let inner = Arc::clone(&self.0); 4842 5694 let fut = async move { 4843 4843 - <T as PlaylistService>::get_first_index(&inner, request).await 5695 5695 + <T as PlaylistService>::get_first_index(&inner, request) 5696 5696 + .await 4844 5697 }; 4845 5698 Box::pin(fut) 4846 5699 } ··· 4870 5723 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex" => { 4871 5724 #[allow(non_camel_case_types)] 4872 5725 struct GetDisplayIndexSvc<T: PlaylistService>(pub Arc<T>); 4873 4873 - impl<T: PlaylistService> 4874 4874 - tonic::server::UnaryService<super::GetDisplayIndexRequest> 4875 4875 - for GetDisplayIndexSvc<T> 4876 4876 - { 5726 5726 + impl< 5727 5727 + T: PlaylistService, 5728 5728 + > tonic::server::UnaryService<super::GetDisplayIndexRequest> 5729 5729 + for GetDisplayIndexSvc<T> { 4877 5730 type Response = super::GetDisplayIndexResponse; 4878 4878 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5731 5731 + type Future = BoxFuture< 5732 5732 + tonic::Response<Self::Response>, 5733 5733 + tonic::Status, 5734 5734 + >; 4879 5735 fn call( 4880 5736 &mut self, 4881 5737 request: tonic::Request<super::GetDisplayIndexRequest>, 4882 5738 ) -> Self::Future { 4883 5739 let inner = Arc::clone(&self.0); 4884 5740 let fut = async move { 4885 4885 - <T as PlaylistService>::get_display_index(&inner, request).await 5741 5741 + <T as PlaylistService>::get_display_index(&inner, request) 5742 5742 + .await 4886 5743 }; 4887 5744 Box::pin(fut) 4888 5745 } ··· 4912 5769 "/rockbox.v1alpha1.PlaylistService/Amount" => { 4913 5770 #[allow(non_camel_case_types)] 4914 5771 struct AmountSvc<T: PlaylistService>(pub Arc<T>); 4915 4915 - impl<T: PlaylistService> tonic::server::UnaryService<super::AmountRequest> for AmountSvc<T> { 5772 5772 + impl< 5773 5773 + T: PlaylistService, 5774 5774 + > tonic::server::UnaryService<super::AmountRequest> 5775 5775 + for AmountSvc<T> { 4916 5776 type Response = super::AmountResponse; 4917 4917 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5777 5777 + type Future = BoxFuture< 5778 5778 + tonic::Response<Self::Response>, 5779 5779 + tonic::Status, 5780 5780 + >; 4918 5781 fn call( 4919 5782 &mut self, 4920 5783 request: tonic::Request<super::AmountRequest>, ··· 4951 5814 "/rockbox.v1alpha1.PlaylistService/PlaylistResume" => { 4952 5815 #[allow(non_camel_case_types)] 4953 5816 struct PlaylistResumeSvc<T: PlaylistService>(pub Arc<T>); 4954 4954 - impl<T: PlaylistService> 4955 4955 - tonic::server::UnaryService<super::PlaylistResumeRequest> 4956 4956 - for PlaylistResumeSvc<T> 4957 4957 - { 5817 5817 + impl< 5818 5818 + T: PlaylistService, 5819 5819 + > tonic::server::UnaryService<super::PlaylistResumeRequest> 5820 5820 + for PlaylistResumeSvc<T> { 4958 5821 type Response = super::PlaylistResumeResponse; 4959 4959 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5822 5822 + type Future = BoxFuture< 5823 5823 + tonic::Response<Self::Response>, 5824 5824 + tonic::Status, 5825 5825 + >; 4960 5826 fn call( 4961 5827 &mut self, 4962 5828 request: tonic::Request<super::PlaylistResumeRequest>, 4963 5829 ) -> Self::Future { 4964 5830 let inner = Arc::clone(&self.0); 4965 5831 let fut = async move { 4966 4966 - <T as PlaylistService>::playlist_resume(&inner, request).await 5832 5832 + <T as PlaylistService>::playlist_resume(&inner, request) 5833 5833 + .await 4967 5834 }; 4968 5835 Box::pin(fut) 4969 5836 } ··· 4993 5860 "/rockbox.v1alpha1.PlaylistService/ResumeTrack" => { 4994 5861 #[allow(non_camel_case_types)] 4995 5862 struct ResumeTrackSvc<T: PlaylistService>(pub Arc<T>); 4996 4996 - impl<T: PlaylistService> tonic::server::UnaryService<super::ResumeTrackRequest> 4997 4997 - for ResumeTrackSvc<T> 4998 4998 - { 5863 5863 + impl< 5864 5864 + T: PlaylistService, 5865 5865 + > tonic::server::UnaryService<super::ResumeTrackRequest> 5866 5866 + for ResumeTrackSvc<T> { 4999 5867 type Response = super::ResumeTrackResponse; 5000 5000 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5868 5868 + type Future = BoxFuture< 5869 5869 + tonic::Response<Self::Response>, 5870 5870 + tonic::Status, 5871 5871 + >; 5001 5872 fn call( 5002 5873 &mut self, 5003 5874 request: tonic::Request<super::ResumeTrackRequest>, ··· 5034 5905 "/rockbox.v1alpha1.PlaylistService/SetModified" => { 5035 5906 #[allow(non_camel_case_types)] 5036 5907 struct SetModifiedSvc<T: PlaylistService>(pub Arc<T>); 5037 5037 - impl<T: PlaylistService> tonic::server::UnaryService<super::SetModifiedRequest> 5038 5038 - for SetModifiedSvc<T> 5039 5039 - { 5908 5908 + impl< 5909 5909 + T: PlaylistService, 5910 5910 + > tonic::server::UnaryService<super::SetModifiedRequest> 5911 5911 + for SetModifiedSvc<T> { 5040 5912 type Response = super::SetModifiedResponse; 5041 5041 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5913 5913 + type Future = BoxFuture< 5914 5914 + tonic::Response<Self::Response>, 5915 5915 + tonic::Status, 5916 5916 + >; 5042 5917 fn call( 5043 5918 &mut self, 5044 5919 request: tonic::Request<super::SetModifiedRequest>, ··· 5075 5950 "/rockbox.v1alpha1.PlaylistService/Start" => { 5076 5951 #[allow(non_camel_case_types)] 5077 5952 struct StartSvc<T: PlaylistService>(pub Arc<T>); 5078 5078 - impl<T: PlaylistService> tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 5953 5953 + impl< 5954 5954 + T: PlaylistService, 5955 5955 + > tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 5079 5956 type Response = super::StartResponse; 5080 5080 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5957 5957 + type Future = BoxFuture< 5958 5958 + tonic::Response<Self::Response>, 5959 5959 + tonic::Status, 5960 5960 + >; 5081 5961 fn call( 5082 5962 &mut self, 5083 5963 request: tonic::Request<super::StartRequest>, 5084 5964 ) -> Self::Future { 5085 5965 let inner = Arc::clone(&self.0); 5086 5086 - let fut = 5087 5087 - async move { <T as PlaylistService>::start(&inner, request).await }; 5966 5966 + let fut = async move { 5967 5967 + <T as PlaylistService>::start(&inner, request).await 5968 5968 + }; 5088 5969 Box::pin(fut) 5089 5970 } 5090 5971 } ··· 5113 5994 "/rockbox.v1alpha1.PlaylistService/Sync" => { 5114 5995 #[allow(non_camel_case_types)] 5115 5996 struct SyncSvc<T: PlaylistService>(pub Arc<T>); 5116 5116 - impl<T: PlaylistService> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 5997 5997 + impl< 5998 5998 + T: PlaylistService, 5999 5999 + > tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 5117 6000 type Response = super::SyncResponse; 5118 5118 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6001 6001 + type Future = BoxFuture< 6002 6002 + tonic::Response<Self::Response>, 6003 6003 + tonic::Status, 6004 6004 + >; 5119 6005 fn call( 5120 6006 &mut self, 5121 6007 request: tonic::Request<super::SyncRequest>, 5122 6008 ) -> Self::Future { 5123 6009 let inner = Arc::clone(&self.0); 5124 5124 - let fut = 5125 5125 - async move { <T as PlaylistService>::sync(&inner, request).await }; 6010 6010 + let fut = async move { 6011 6011 + <T as PlaylistService>::sync(&inner, request).await 6012 6012 + }; 5126 6013 Box::pin(fut) 5127 6014 } 5128 6015 } ··· 5151 6038 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks" => { 5152 6039 #[allow(non_camel_case_types)] 5153 6040 struct RemoveAllTracksSvc<T: PlaylistService>(pub Arc<T>); 5154 5154 - impl<T: PlaylistService> 5155 5155 - tonic::server::UnaryService<super::RemoveAllTracksRequest> 5156 5156 - for RemoveAllTracksSvc<T> 5157 5157 - { 6041 6041 + impl< 6042 6042 + T: PlaylistService, 6043 6043 + > tonic::server::UnaryService<super::RemoveAllTracksRequest> 6044 6044 + for RemoveAllTracksSvc<T> { 5158 6045 type Response = super::RemoveAllTracksResponse; 5159 5159 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6046 6046 + type Future = BoxFuture< 6047 6047 + tonic::Response<Self::Response>, 6048 6048 + tonic::Status, 6049 6049 + >; 5160 6050 fn call( 5161 6051 &mut self, 5162 6052 request: tonic::Request<super::RemoveAllTracksRequest>, 5163 6053 ) -> Self::Future { 5164 6054 let inner = Arc::clone(&self.0); 5165 6055 let fut = async move { 5166 5166 - <T as PlaylistService>::remove_all_tracks(&inner, request).await 6056 6056 + <T as PlaylistService>::remove_all_tracks(&inner, request) 6057 6057 + .await 5167 6058 }; 5168 6059 Box::pin(fut) 5169 6060 } ··· 5193 6084 "/rockbox.v1alpha1.PlaylistService/RemoveTracks" => { 5194 6085 #[allow(non_camel_case_types)] 5195 6086 struct RemoveTracksSvc<T: PlaylistService>(pub Arc<T>); 5196 5196 - impl<T: PlaylistService> tonic::server::UnaryService<super::RemoveTracksRequest> 5197 5197 - for RemoveTracksSvc<T> 5198 5198 - { 6087 6087 + impl< 6088 6088 + T: PlaylistService, 6089 6089 + > tonic::server::UnaryService<super::RemoveTracksRequest> 6090 6090 + for RemoveTracksSvc<T> { 5199 6091 type Response = super::RemoveTracksResponse; 5200 5200 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6092 6092 + type Future = BoxFuture< 6093 6093 + tonic::Response<Self::Response>, 6094 6094 + tonic::Status, 6095 6095 + >; 5201 6096 fn call( 5202 6097 &mut self, 5203 6098 request: tonic::Request<super::RemoveTracksRequest>, ··· 5234 6129 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist" => { 5235 6130 #[allow(non_camel_case_types)] 5236 6131 struct CreatePlaylistSvc<T: PlaylistService>(pub Arc<T>); 5237 5237 - impl<T: PlaylistService> 5238 5238 - tonic::server::UnaryService<super::CreatePlaylistRequest> 5239 5239 - for CreatePlaylistSvc<T> 5240 5240 - { 6132 6132 + impl< 6133 6133 + T: PlaylistService, 6134 6134 + > tonic::server::UnaryService<super::CreatePlaylistRequest> 6135 6135 + for CreatePlaylistSvc<T> { 5241 6136 type Response = super::CreatePlaylistResponse; 5242 5242 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6137 6137 + type Future = BoxFuture< 6138 6138 + tonic::Response<Self::Response>, 6139 6139 + tonic::Status, 6140 6140 + >; 5243 6141 fn call( 5244 6142 &mut self, 5245 6143 request: tonic::Request<super::CreatePlaylistRequest>, 5246 6144 ) -> Self::Future { 5247 6145 let inner = Arc::clone(&self.0); 5248 6146 let fut = async move { 5249 5249 - <T as PlaylistService>::create_playlist(&inner, request).await 6147 6147 + <T as PlaylistService>::create_playlist(&inner, request) 6148 6148 + .await 5250 6149 }; 5251 6150 Box::pin(fut) 5252 6151 } ··· 5276 6175 "/rockbox.v1alpha1.PlaylistService/InsertTracks" => { 5277 6176 #[allow(non_camel_case_types)] 5278 6177 struct InsertTracksSvc<T: PlaylistService>(pub Arc<T>); 5279 5279 - impl<T: PlaylistService> tonic::server::UnaryService<super::InsertTracksRequest> 5280 5280 - for InsertTracksSvc<T> 5281 5281 - { 6178 6178 + impl< 6179 6179 + T: PlaylistService, 6180 6180 + > tonic::server::UnaryService<super::InsertTracksRequest> 6181 6181 + for InsertTracksSvc<T> { 5282 6182 type Response = super::InsertTracksResponse; 5283 5283 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6183 6183 + type Future = BoxFuture< 6184 6184 + tonic::Response<Self::Response>, 6185 6185 + tonic::Status, 6186 6186 + >; 5284 6187 fn call( 5285 6188 &mut self, 5286 6189 request: tonic::Request<super::InsertTracksRequest>, ··· 5317 6220 "/rockbox.v1alpha1.PlaylistService/InsertDirectory" => { 5318 6221 #[allow(non_camel_case_types)] 5319 6222 struct InsertDirectorySvc<T: PlaylistService>(pub Arc<T>); 5320 5320 - impl<T: PlaylistService> 5321 5321 - tonic::server::UnaryService<super::InsertDirectoryRequest> 5322 5322 - for InsertDirectorySvc<T> 5323 5323 - { 6223 6223 + impl< 6224 6224 + T: PlaylistService, 6225 6225 + > tonic::server::UnaryService<super::InsertDirectoryRequest> 6226 6226 + for InsertDirectorySvc<T> { 5324 6227 type Response = super::InsertDirectoryResponse; 5325 5325 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6228 6228 + type Future = BoxFuture< 6229 6229 + tonic::Response<Self::Response>, 6230 6230 + tonic::Status, 6231 6231 + >; 5326 6232 fn call( 5327 6233 &mut self, 5328 6234 request: tonic::Request<super::InsertDirectoryRequest>, 5329 6235 ) -> Self::Future { 5330 6236 let inner = Arc::clone(&self.0); 5331 6237 let fut = async move { 5332 5332 - <T as PlaylistService>::insert_directory(&inner, request).await 6238 6238 + <T as PlaylistService>::insert_directory(&inner, request) 6239 6239 + .await 5333 6240 }; 5334 6241 Box::pin(fut) 5335 6242 } ··· 5359 6266 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist" => { 5360 6267 #[allow(non_camel_case_types)] 5361 6268 struct InsertPlaylistSvc<T: PlaylistService>(pub Arc<T>); 5362 5362 - impl<T: PlaylistService> 5363 5363 - tonic::server::UnaryService<super::InsertPlaylistRequest> 5364 5364 - for InsertPlaylistSvc<T> 5365 5365 - { 6269 6269 + impl< 6270 6270 + T: PlaylistService, 6271 6271 + > tonic::server::UnaryService<super::InsertPlaylistRequest> 6272 6272 + for InsertPlaylistSvc<T> { 5366 6273 type Response = super::InsertPlaylistResponse; 5367 5367 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6274 6274 + type Future = BoxFuture< 6275 6275 + tonic::Response<Self::Response>, 6276 6276 + tonic::Status, 6277 6277 + >; 5368 6278 fn call( 5369 6279 &mut self, 5370 6280 request: tonic::Request<super::InsertPlaylistRequest>, 5371 6281 ) -> Self::Future { 5372 6282 let inner = Arc::clone(&self.0); 5373 6283 let fut = async move { 5374 5374 - <T as PlaylistService>::insert_playlist(&inner, request).await 6284 6284 + <T as PlaylistService>::insert_playlist(&inner, request) 6285 6285 + .await 5375 6286 }; 5376 6287 Box::pin(fut) 5377 6288 } ··· 5401 6312 "/rockbox.v1alpha1.PlaylistService/InsertAlbum" => { 5402 6313 #[allow(non_camel_case_types)] 5403 6314 struct InsertAlbumSvc<T: PlaylistService>(pub Arc<T>); 5404 5404 - impl<T: PlaylistService> tonic::server::UnaryService<super::InsertAlbumRequest> 5405 5405 - for InsertAlbumSvc<T> 5406 5406 - { 6315 6315 + impl< 6316 6316 + T: PlaylistService, 6317 6317 + > tonic::server::UnaryService<super::InsertAlbumRequest> 6318 6318 + for InsertAlbumSvc<T> { 5407 6319 type Response = super::InsertAlbumResponse; 5408 5408 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6320 6320 + type Future = BoxFuture< 6321 6321 + tonic::Response<Self::Response>, 6322 6322 + tonic::Status, 6323 6323 + >; 5409 6324 fn call( 5410 6325 &mut self, 5411 6326 request: tonic::Request<super::InsertAlbumRequest>, ··· 5442 6357 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks" => { 5443 6358 #[allow(non_camel_case_types)] 5444 6359 struct InsertArtistTracksSvc<T: PlaylistService>(pub Arc<T>); 5445 5445 - impl<T: PlaylistService> 5446 5446 - tonic::server::UnaryService<super::InsertArtistTracksRequest> 5447 5447 - for InsertArtistTracksSvc<T> 5448 5448 - { 6360 6360 + impl< 6361 6361 + T: PlaylistService, 6362 6362 + > tonic::server::UnaryService<super::InsertArtistTracksRequest> 6363 6363 + for InsertArtistTracksSvc<T> { 5449 6364 type Response = super::InsertArtistTracksResponse; 5450 5450 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6365 6365 + type Future = BoxFuture< 6366 6366 + tonic::Response<Self::Response>, 6367 6367 + tonic::Status, 6368 6368 + >; 5451 6369 fn call( 5452 6370 &mut self, 5453 6371 request: tonic::Request<super::InsertArtistTracksRequest>, 5454 6372 ) -> Self::Future { 5455 6373 let inner = Arc::clone(&self.0); 5456 6374 let fut = async move { 5457 5457 - <T as PlaylistService>::insert_artist_tracks(&inner, request).await 6375 6375 + <T as PlaylistService>::insert_artist_tracks( 6376 6376 + &inner, 6377 6377 + request, 6378 6378 + ) 6379 6379 + .await 5458 6380 }; 5459 6381 Box::pin(fut) 5460 6382 } ··· 5484 6406 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist" => { 5485 6407 #[allow(non_camel_case_types)] 5486 6408 struct ShufflePlaylistSvc<T: PlaylistService>(pub Arc<T>); 5487 5487 - impl<T: PlaylistService> 5488 5488 - tonic::server::UnaryService<super::ShufflePlaylistRequest> 5489 5489 - for ShufflePlaylistSvc<T> 5490 5490 - { 6409 6409 + impl< 6410 6410 + T: PlaylistService, 6411 6411 + > tonic::server::UnaryService<super::ShufflePlaylistRequest> 6412 6412 + for ShufflePlaylistSvc<T> { 5491 6413 type Response = super::ShufflePlaylistResponse; 5492 5492 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6414 6414 + type Future = BoxFuture< 6415 6415 + tonic::Response<Self::Response>, 6416 6416 + tonic::Status, 6417 6417 + >; 5493 6418 fn call( 5494 6419 &mut self, 5495 6420 request: tonic::Request<super::ShufflePlaylistRequest>, 5496 6421 ) -> Self::Future { 5497 6422 let inner = Arc::clone(&self.0); 5498 6423 let fut = async move { 5499 5499 - <T as PlaylistService>::shuffle_playlist(&inner, request).await 6424 6424 + <T as PlaylistService>::shuffle_playlist(&inner, request) 6425 6425 + .await 5500 6426 }; 5501 6427 Box::pin(fut) 5502 6428 } ··· 5523 6449 }; 5524 6450 Box::pin(fut) 5525 6451 } 5526 5526 - _ => Box::pin(async move { 5527 5527 - let mut response = http::Response::new(empty_body()); 5528 5528 - let headers = response.headers_mut(); 5529 5529 - headers.insert( 5530 5530 - tonic::Status::GRPC_STATUS, 5531 5531 - (tonic::Code::Unimplemented as i32).into(), 5532 5532 - ); 5533 5533 - headers.insert( 5534 5534 - http::header::CONTENT_TYPE, 5535 5535 - tonic::metadata::GRPC_CONTENT_TYPE, 5536 5536 - ); 5537 5537 - Ok(response) 5538 5538 - }), 6452 6452 + _ => { 6453 6453 + Box::pin(async move { 6454 6454 + let mut response = http::Response::new(empty_body()); 6455 6455 + let headers = response.headers_mut(); 6456 6456 + headers 6457 6457 + .insert( 6458 6458 + tonic::Status::GRPC_STATUS, 6459 6459 + (tonic::Code::Unimplemented as i32).into(), 6460 6460 + ); 6461 6461 + headers 6462 6462 + .insert( 6463 6463 + http::header::CONTENT_TYPE, 6464 6464 + tonic::metadata::GRPC_CONTENT_TYPE, 6465 6465 + ); 6466 6466 + Ok(response) 6467 6467 + }) 6468 6468 + } 5539 6469 } 5540 6470 } 5541 6471 } ··· 6045 6975 dead_code, 6046 6976 missing_docs, 6047 6977 clippy::wildcard_imports, 6048 6048 - clippy::let_unit_value 6978 6978 + clippy::let_unit_value, 6049 6979 )] 6050 6050 - use tonic::codegen::http::Uri; 6051 6980 use tonic::codegen::*; 6981 6981 + use tonic::codegen::http::Uri; 6052 6982 #[derive(Debug, Clone)] 6053 6983 pub struct SettingsServiceClient<T> { 6054 6984 inner: tonic::client::Grpc<T>, ··· 6092 7022 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 6093 7023 >, 6094 7024 >, 6095 6095 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 6096 6096 - Into<StdError> + std::marker::Send + std::marker::Sync, 7025 7025 + <T as tonic::codegen::Service< 7026 7026 + http::Request<tonic::body::BoxBody>, 7027 7027 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6097 7028 { 6098 7029 SettingsServiceClient::new(InterceptedService::new(inner, interceptor)) 6099 7030 } ··· 6131 7062 pub async fn get_settings_list( 6132 7063 &mut self, 6133 7064 request: impl tonic::IntoRequest<super::GetSettingsListRequest>, 6134 6134 - ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status> 6135 6135 - { 6136 6136 - self.inner.ready().await.map_err(|e| { 6137 6137 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6138 6138 - })?; 7065 7065 + ) -> std::result::Result< 7066 7066 + tonic::Response<super::GetSettingsListResponse>, 7067 7067 + tonic::Status, 7068 7068 + > { 7069 7069 + self.inner 7070 7070 + .ready() 7071 7071 + .await 7072 7072 + .map_err(|e| { 7073 7073 + tonic::Status::unknown( 7074 7074 + format!("Service was not ready: {}", e.into()), 7075 7075 + ) 7076 7076 + })?; 6139 7077 let codec = tonic::codec::ProstCodec::default(); 6140 7078 let path = http::uri::PathAndQuery::from_static( 6141 7079 "/rockbox.v1alpha1.SettingsService/GetSettingsList", 6142 7080 ); 6143 7081 let mut req = request.into_request(); 6144 6144 - req.extensions_mut().insert(GrpcMethod::new( 6145 6145 - "rockbox.v1alpha1.SettingsService", 6146 6146 - "GetSettingsList", 6147 6147 - )); 7082 7082 + req.extensions_mut() 7083 7083 + .insert( 7084 7084 + GrpcMethod::new( 7085 7085 + "rockbox.v1alpha1.SettingsService", 7086 7086 + "GetSettingsList", 7087 7087 + ), 7088 7088 + ); 6148 7089 self.inner.unary(req, path, codec).await 6149 7090 } 6150 7091 pub async fn get_global_settings( 6151 7092 &mut self, 6152 7093 request: impl tonic::IntoRequest<super::GetGlobalSettingsRequest>, 6153 6153 - ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status> 6154 6154 - { 6155 6155 - self.inner.ready().await.map_err(|e| { 6156 6156 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6157 6157 - })?; 7094 7094 + ) -> std::result::Result< 7095 7095 + tonic::Response<super::GetGlobalSettingsResponse>, 7096 7096 + tonic::Status, 7097 7097 + > { 7098 7098 + self.inner 7099 7099 + .ready() 7100 7100 + .await 7101 7101 + .map_err(|e| { 7102 7102 + tonic::Status::unknown( 7103 7103 + format!("Service was not ready: {}", e.into()), 7104 7104 + ) 7105 7105 + })?; 6158 7106 let codec = tonic::codec::ProstCodec::default(); 6159 7107 let path = http::uri::PathAndQuery::from_static( 6160 7108 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings", 6161 7109 ); 6162 7110 let mut req = request.into_request(); 6163 6163 - req.extensions_mut().insert(GrpcMethod::new( 6164 6164 - "rockbox.v1alpha1.SettingsService", 6165 6165 - "GetGlobalSettings", 6166 6166 - )); 7111 7111 + req.extensions_mut() 7112 7112 + .insert( 7113 7113 + GrpcMethod::new( 7114 7114 + "rockbox.v1alpha1.SettingsService", 7115 7115 + "GetGlobalSettings", 7116 7116 + ), 7117 7117 + ); 6167 7118 self.inner.unary(req, path, codec).await 6168 7119 } 6169 7120 pub async fn save_settings( 6170 7121 &mut self, 6171 7122 request: impl tonic::IntoRequest<super::SaveSettingsRequest>, 6172 6172 - ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status> 6173 6173 - { 6174 6174 - self.inner.ready().await.map_err(|e| { 6175 6175 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6176 6176 - })?; 7123 7123 + ) -> std::result::Result< 7124 7124 + tonic::Response<super::SaveSettingsResponse>, 7125 7125 + tonic::Status, 7126 7126 + > { 7127 7127 + self.inner 7128 7128 + .ready() 7129 7129 + .await 7130 7130 + .map_err(|e| { 7131 7131 + tonic::Status::unknown( 7132 7132 + format!("Service was not ready: {}", e.into()), 7133 7133 + ) 7134 7134 + })?; 6177 7135 let codec = tonic::codec::ProstCodec::default(); 6178 7136 let path = http::uri::PathAndQuery::from_static( 6179 7137 "/rockbox.v1alpha1.SettingsService/SaveSettings", 6180 7138 ); 6181 7139 let mut req = request.into_request(); 6182 6182 - req.extensions_mut().insert(GrpcMethod::new( 6183 6183 - "rockbox.v1alpha1.SettingsService", 6184 6184 - "SaveSettings", 6185 6185 - )); 7140 7140 + req.extensions_mut() 7141 7141 + .insert( 7142 7142 + GrpcMethod::new("rockbox.v1alpha1.SettingsService", "SaveSettings"), 7143 7143 + ); 6186 7144 self.inner.unary(req, path, codec).await 6187 7145 } 6188 7146 } ··· 6194 7152 dead_code, 6195 7153 missing_docs, 6196 7154 clippy::wildcard_imports, 6197 6197 - clippy::let_unit_value 7155 7155 + clippy::let_unit_value, 6198 7156 )] 6199 7157 use tonic::codegen::*; 6200 7158 /// Generated trait containing gRPC methods that should be implemented for use with SettingsServiceServer. ··· 6203 7161 async fn get_settings_list( 6204 7162 &self, 6205 7163 request: tonic::Request<super::GetSettingsListRequest>, 6206 6206 - ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status>; 7164 7164 + ) -> std::result::Result< 7165 7165 + tonic::Response<super::GetSettingsListResponse>, 7166 7166 + tonic::Status, 7167 7167 + >; 6207 7168 async fn get_global_settings( 6208 7169 &self, 6209 7170 request: tonic::Request<super::GetGlobalSettingsRequest>, 6210 6210 - ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status>; 7171 7171 + ) -> std::result::Result< 7172 7172 + tonic::Response<super::GetGlobalSettingsResponse>, 7173 7173 + tonic::Status, 7174 7174 + >; 6211 7175 async fn save_settings( 6212 7176 &self, 6213 7177 request: tonic::Request<super::SaveSettingsRequest>, 6214 6214 - ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>; 7178 7178 + ) -> std::result::Result< 7179 7179 + tonic::Response<super::SaveSettingsResponse>, 7180 7180 + tonic::Status, 7181 7181 + >; 6215 7182 } 6216 7183 #[derive(Debug)] 6217 7184 pub struct SettingsServiceServer<T> { ··· 6234 7201 max_encoding_message_size: None, 6235 7202 } 6236 7203 } 6237 6237 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 7204 7204 + pub fn with_interceptor<F>( 7205 7205 + inner: T, 7206 7206 + interceptor: F, 7207 7207 + ) -> InterceptedService<Self, F> 6238 7208 where 6239 7209 F: tonic::service::Interceptor, 6240 7210 { ··· 6289 7259 "/rockbox.v1alpha1.SettingsService/GetSettingsList" => { 6290 7260 #[allow(non_camel_case_types)] 6291 7261 struct GetSettingsListSvc<T: SettingsService>(pub Arc<T>); 6292 6292 - impl<T: SettingsService> 6293 6293 - tonic::server::UnaryService<super::GetSettingsListRequest> 6294 6294 - for GetSettingsListSvc<T> 6295 6295 - { 7262 7262 + impl< 7263 7263 + T: SettingsService, 7264 7264 + > tonic::server::UnaryService<super::GetSettingsListRequest> 7265 7265 + for GetSettingsListSvc<T> { 6296 7266 type Response = super::GetSettingsListResponse; 6297 6297 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7267 7267 + type Future = BoxFuture< 7268 7268 + tonic::Response<Self::Response>, 7269 7269 + tonic::Status, 7270 7270 + >; 6298 7271 fn call( 6299 7272 &mut self, 6300 7273 request: tonic::Request<super::GetSettingsListRequest>, 6301 7274 ) -> Self::Future { 6302 7275 let inner = Arc::clone(&self.0); 6303 7276 let fut = async move { 6304 6304 - <T as SettingsService>::get_settings_list(&inner, request).await 7277 7277 + <T as SettingsService>::get_settings_list(&inner, request) 7278 7278 + .await 6305 7279 }; 6306 7280 Box::pin(fut) 6307 7281 } ··· 6331 7305 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings" => { 6332 7306 #[allow(non_camel_case_types)] 6333 7307 struct GetGlobalSettingsSvc<T: SettingsService>(pub Arc<T>); 6334 6334 - impl<T: SettingsService> 6335 6335 - tonic::server::UnaryService<super::GetGlobalSettingsRequest> 6336 6336 - for GetGlobalSettingsSvc<T> 6337 6337 - { 7308 7308 + impl< 7309 7309 + T: SettingsService, 7310 7310 + > tonic::server::UnaryService<super::GetGlobalSettingsRequest> 7311 7311 + for GetGlobalSettingsSvc<T> { 6338 7312 type Response = super::GetGlobalSettingsResponse; 6339 6339 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7313 7313 + type Future = BoxFuture< 7314 7314 + tonic::Response<Self::Response>, 7315 7315 + tonic::Status, 7316 7316 + >; 6340 7317 fn call( 6341 7318 &mut self, 6342 7319 request: tonic::Request<super::GetGlobalSettingsRequest>, 6343 7320 ) -> Self::Future { 6344 7321 let inner = Arc::clone(&self.0); 6345 7322 let fut = async move { 6346 6346 - <T as SettingsService>::get_global_settings(&inner, request).await 7323 7323 + <T as SettingsService>::get_global_settings(&inner, request) 7324 7324 + .await 6347 7325 }; 6348 7326 Box::pin(fut) 6349 7327 } ··· 6373 7351 "/rockbox.v1alpha1.SettingsService/SaveSettings" => { 6374 7352 #[allow(non_camel_case_types)] 6375 7353 struct SaveSettingsSvc<T: SettingsService>(pub Arc<T>); 6376 6376 - impl<T: SettingsService> tonic::server::UnaryService<super::SaveSettingsRequest> 6377 6377 - for SaveSettingsSvc<T> 6378 6378 - { 7354 7354 + impl< 7355 7355 + T: SettingsService, 7356 7356 + > tonic::server::UnaryService<super::SaveSettingsRequest> 7357 7357 + for SaveSettingsSvc<T> { 6379 7358 type Response = super::SaveSettingsResponse; 6380 6380 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7359 7359 + type Future = BoxFuture< 7360 7360 + tonic::Response<Self::Response>, 7361 7361 + tonic::Status, 7362 7362 + >; 6381 7363 fn call( 6382 7364 &mut self, 6383 7365 request: tonic::Request<super::SaveSettingsRequest>, ··· 6411 7393 }; 6412 7394 Box::pin(fut) 6413 7395 } 6414 6414 - _ => Box::pin(async move { 6415 6415 - let mut response = http::Response::new(empty_body()); 6416 6416 - let headers = response.headers_mut(); 6417 6417 - headers.insert( 6418 6418 - tonic::Status::GRPC_STATUS, 6419 6419 - (tonic::Code::Unimplemented as i32).into(), 6420 6420 - ); 6421 6421 - headers.insert( 6422 6422 - http::header::CONTENT_TYPE, 6423 6423 - tonic::metadata::GRPC_CONTENT_TYPE, 6424 6424 - ); 6425 6425 - Ok(response) 6426 6426 - }), 7396 7396 + _ => { 7397 7397 + Box::pin(async move { 7398 7398 + let mut response = http::Response::new(empty_body()); 7399 7399 + let headers = response.headers_mut(); 7400 7400 + headers 7401 7401 + .insert( 7402 7402 + tonic::Status::GRPC_STATUS, 7403 7403 + (tonic::Code::Unimplemented as i32).into(), 7404 7404 + ); 7405 7405 + headers 7406 7406 + .insert( 7407 7407 + http::header::CONTENT_TYPE, 7408 7408 + tonic::metadata::GRPC_CONTENT_TYPE, 7409 7409 + ); 7410 7410 + Ok(response) 7411 7411 + }) 7412 7412 + } 6427 7413 } 6428 7414 } 6429 7415 } ··· 6581 7567 dead_code, 6582 7568 missing_docs, 6583 7569 clippy::wildcard_imports, 6584 6584 - clippy::let_unit_value 7570 7570 + clippy::let_unit_value, 6585 7571 )] 6586 6586 - use tonic::codegen::http::Uri; 6587 7572 use tonic::codegen::*; 7573 7573 + use tonic::codegen::http::Uri; 6588 7574 #[derive(Debug, Clone)] 6589 7575 pub struct SoundServiceClient<T> { 6590 7576 inner: tonic::client::Grpc<T>, ··· 6628 7614 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 6629 7615 >, 6630 7616 >, 6631 6631 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 6632 6632 - Into<StdError> + std::marker::Send + std::marker::Sync, 7617 7617 + <T as tonic::codegen::Service< 7618 7618 + http::Request<tonic::body::BoxBody>, 7619 7619 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6633 7620 { 6634 7621 SoundServiceClient::new(InterceptedService::new(inner, interceptor)) 6635 7622 } ··· 6667 7654 pub async fn adjust_volume( 6668 7655 &mut self, 6669 7656 request: impl tonic::IntoRequest<super::AdjustVolumeRequest>, 6670 6670 - ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status> 6671 6671 - { 6672 6672 - self.inner.ready().await.map_err(|e| { 6673 6673 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6674 6674 - })?; 7657 7657 + ) -> std::result::Result< 7658 7658 + tonic::Response<super::AdjustVolumeResponse>, 7659 7659 + tonic::Status, 7660 7660 + > { 7661 7661 + self.inner 7662 7662 + .ready() 7663 7663 + .await 7664 7664 + .map_err(|e| { 7665 7665 + tonic::Status::unknown( 7666 7666 + format!("Service was not ready: {}", e.into()), 7667 7667 + ) 7668 7668 + })?; 6675 7669 let codec = tonic::codec::ProstCodec::default(); 6676 6676 - let path = 6677 6677 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/AdjustVolume"); 7670 7670 + let path = http::uri::PathAndQuery::from_static( 7671 7671 + "/rockbox.v1alpha1.SoundService/AdjustVolume", 7672 7672 + ); 6678 7673 let mut req = request.into_request(); 6679 6679 - req.extensions_mut().insert(GrpcMethod::new( 6680 6680 - "rockbox.v1alpha1.SoundService", 6681 6681 - "AdjustVolume", 6682 6682 - )); 7674 7674 + req.extensions_mut() 7675 7675 + .insert( 7676 7676 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "AdjustVolume"), 7677 7677 + ); 6683 7678 self.inner.unary(req, path, codec).await 6684 7679 } 6685 7680 pub async fn sound_set( 6686 7681 &mut self, 6687 7682 request: impl tonic::IntoRequest<super::SoundSetRequest>, 6688 6688 - ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status> { 6689 6689 - self.inner.ready().await.map_err(|e| { 6690 6690 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6691 6691 - })?; 7683 7683 + ) -> std::result::Result< 7684 7684 + tonic::Response<super::SoundSetResponse>, 7685 7685 + tonic::Status, 7686 7686 + > { 7687 7687 + self.inner 7688 7688 + .ready() 7689 7689 + .await 7690 7690 + .map_err(|e| { 7691 7691 + tonic::Status::unknown( 7692 7692 + format!("Service was not ready: {}", e.into()), 7693 7693 + ) 7694 7694 + })?; 6692 7695 let codec = tonic::codec::ProstCodec::default(); 6693 6693 - let path = 6694 6694 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundSet"); 7696 7696 + let path = http::uri::PathAndQuery::from_static( 7697 7697 + "/rockbox.v1alpha1.SoundService/SoundSet", 7698 7698 + ); 6695 7699 let mut req = request.into_request(); 6696 7700 req.extensions_mut() 6697 7701 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundSet")); ··· 6700 7704 pub async fn sound_current( 6701 7705 &mut self, 6702 7706 request: impl tonic::IntoRequest<super::SoundCurrentRequest>, 6703 6703 - ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status> 6704 6704 - { 6705 6705 - self.inner.ready().await.map_err(|e| { 6706 6706 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6707 6707 - })?; 7707 7707 + ) -> std::result::Result< 7708 7708 + tonic::Response<super::SoundCurrentResponse>, 7709 7709 + tonic::Status, 7710 7710 + > { 7711 7711 + self.inner 7712 7712 + .ready() 7713 7713 + .await 7714 7714 + .map_err(|e| { 7715 7715 + tonic::Status::unknown( 7716 7716 + format!("Service was not ready: {}", e.into()), 7717 7717 + ) 7718 7718 + })?; 6708 7719 let codec = tonic::codec::ProstCodec::default(); 6709 6709 - let path = 6710 6710 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundCurrent"); 7720 7720 + let path = http::uri::PathAndQuery::from_static( 7721 7721 + "/rockbox.v1alpha1.SoundService/SoundCurrent", 7722 7722 + ); 6711 7723 let mut req = request.into_request(); 6712 6712 - req.extensions_mut().insert(GrpcMethod::new( 6713 6713 - "rockbox.v1alpha1.SoundService", 6714 6714 - "SoundCurrent", 6715 6715 - )); 7724 7724 + req.extensions_mut() 7725 7725 + .insert( 7726 7726 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundCurrent"), 7727 7727 + ); 6716 7728 self.inner.unary(req, path, codec).await 6717 7729 } 6718 7730 pub async fn sound_default( 6719 7731 &mut self, 6720 7732 request: impl tonic::IntoRequest<super::SoundDefaultRequest>, 6721 6721 - ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status> 6722 6722 - { 6723 6723 - self.inner.ready().await.map_err(|e| { 6724 6724 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6725 6725 - })?; 7733 7733 + ) -> std::result::Result< 7734 7734 + tonic::Response<super::SoundDefaultResponse>, 7735 7735 + tonic::Status, 7736 7736 + > { 7737 7737 + self.inner 7738 7738 + .ready() 7739 7739 + .await 7740 7740 + .map_err(|e| { 7741 7741 + tonic::Status::unknown( 7742 7742 + format!("Service was not ready: {}", e.into()), 7743 7743 + ) 7744 7744 + })?; 6726 7745 let codec = tonic::codec::ProstCodec::default(); 6727 6727 - let path = 6728 6728 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundDefault"); 7746 7746 + let path = http::uri::PathAndQuery::from_static( 7747 7747 + "/rockbox.v1alpha1.SoundService/SoundDefault", 7748 7748 + ); 6729 7749 let mut req = request.into_request(); 6730 6730 - req.extensions_mut().insert(GrpcMethod::new( 6731 6731 - "rockbox.v1alpha1.SoundService", 6732 6732 - "SoundDefault", 6733 6733 - )); 7750 7750 + req.extensions_mut() 7751 7751 + .insert( 7752 7752 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundDefault"), 7753 7753 + ); 6734 7754 self.inner.unary(req, path, codec).await 6735 7755 } 6736 7756 pub async fn sound_min( 6737 7757 &mut self, 6738 7758 request: impl tonic::IntoRequest<super::SoundMinRequest>, 6739 6739 - ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status> { 6740 6740 - self.inner.ready().await.map_err(|e| { 6741 6741 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6742 6742 - })?; 7759 7759 + ) -> std::result::Result< 7760 7760 + tonic::Response<super::SoundMinResponse>, 7761 7761 + tonic::Status, 7762 7762 + > { 7763 7763 + self.inner 7764 7764 + .ready() 7765 7765 + .await 7766 7766 + .map_err(|e| { 7767 7767 + tonic::Status::unknown( 7768 7768 + format!("Service was not ready: {}", e.into()), 7769 7769 + ) 7770 7770 + })?; 6743 7771 let codec = tonic::codec::ProstCodec::default(); 6744 6744 - let path = 6745 6745 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMin"); 7772 7772 + let path = http::uri::PathAndQuery::from_static( 7773 7773 + "/rockbox.v1alpha1.SoundService/SoundMin", 7774 7774 + ); 6746 7775 let mut req = request.into_request(); 6747 7776 req.extensions_mut() 6748 7777 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMin")); ··· 6751 7780 pub async fn sound_max( 6752 7781 &mut self, 6753 7782 request: impl tonic::IntoRequest<super::SoundMaxRequest>, 6754 6754 - ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status> { 6755 6755 - self.inner.ready().await.map_err(|e| { 6756 6756 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6757 6757 - })?; 7783 7783 + ) -> std::result::Result< 7784 7784 + tonic::Response<super::SoundMaxResponse>, 7785 7785 + tonic::Status, 7786 7786 + > { 7787 7787 + self.inner 7788 7788 + .ready() 7789 7789 + .await 7790 7790 + .map_err(|e| { 7791 7791 + tonic::Status::unknown( 7792 7792 + format!("Service was not ready: {}", e.into()), 7793 7793 + ) 7794 7794 + })?; 6758 7795 let codec = tonic::codec::ProstCodec::default(); 6759 6759 - let path = 6760 6760 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMax"); 7796 7796 + let path = http::uri::PathAndQuery::from_static( 7797 7797 + "/rockbox.v1alpha1.SoundService/SoundMax", 7798 7798 + ); 6761 7799 let mut req = request.into_request(); 6762 7800 req.extensions_mut() 6763 7801 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMax")); ··· 6766 7804 pub async fn sound_unit( 6767 7805 &mut self, 6768 7806 request: impl tonic::IntoRequest<super::SoundUnitRequest>, 6769 6769 - ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status> { 6770 6770 - self.inner.ready().await.map_err(|e| { 6771 6771 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6772 6772 - })?; 7807 7807 + ) -> std::result::Result< 7808 7808 + tonic::Response<super::SoundUnitResponse>, 7809 7809 + tonic::Status, 7810 7810 + > { 7811 7811 + self.inner 7812 7812 + .ready() 7813 7813 + .await 7814 7814 + .map_err(|e| { 7815 7815 + tonic::Status::unknown( 7816 7816 + format!("Service was not ready: {}", e.into()), 7817 7817 + ) 7818 7818 + })?; 6773 7819 let codec = tonic::codec::ProstCodec::default(); 6774 6774 - let path = 6775 6775 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundUnit"); 7820 7820 + let path = http::uri::PathAndQuery::from_static( 7821 7821 + "/rockbox.v1alpha1.SoundService/SoundUnit", 7822 7822 + ); 6776 7823 let mut req = request.into_request(); 6777 6777 - req.extensions_mut().insert(GrpcMethod::new( 6778 6778 - "rockbox.v1alpha1.SoundService", 6779 6779 - "SoundUnit", 6780 6780 - )); 7824 7824 + req.extensions_mut() 7825 7825 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundUnit")); 6781 7826 self.inner.unary(req, path, codec).await 6782 7827 } 6783 7828 pub async fn sound_val2_phys( 6784 7829 &mut self, 6785 7830 request: impl tonic::IntoRequest<super::SoundVal2PhysRequest>, 6786 6786 - ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status> 6787 6787 - { 6788 6788 - self.inner.ready().await.map_err(|e| { 6789 6789 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6790 6790 - })?; 7831 7831 + ) -> std::result::Result< 7832 7832 + tonic::Response<super::SoundVal2PhysResponse>, 7833 7833 + tonic::Status, 7834 7834 + > { 7835 7835 + self.inner 7836 7836 + .ready() 7837 7837 + .await 7838 7838 + .map_err(|e| { 7839 7839 + tonic::Status::unknown( 7840 7840 + format!("Service was not ready: {}", e.into()), 7841 7841 + ) 7842 7842 + })?; 6791 7843 let codec = tonic::codec::ProstCodec::default(); 6792 7844 let path = http::uri::PathAndQuery::from_static( 6793 7845 "/rockbox.v1alpha1.SoundService/SoundVal2Phys", 6794 7846 ); 6795 7847 let mut req = request.into_request(); 6796 6796 - req.extensions_mut().insert(GrpcMethod::new( 6797 6797 - "rockbox.v1alpha1.SoundService", 6798 6798 - "SoundVal2Phys", 6799 6799 - )); 7848 7848 + req.extensions_mut() 7849 7849 + .insert( 7850 7850 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundVal2Phys"), 7851 7851 + ); 6800 7852 self.inner.unary(req, path, codec).await 6801 7853 } 6802 7854 pub async fn get_pitch( 6803 7855 &mut self, 6804 7856 request: impl tonic::IntoRequest<super::GetPitchRequest>, 6805 6805 - ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status> { 6806 6806 - self.inner.ready().await.map_err(|e| { 6807 6807 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6808 6808 - })?; 7857 7857 + ) -> std::result::Result< 7858 7858 + tonic::Response<super::GetPitchResponse>, 7859 7859 + tonic::Status, 7860 7860 + > { 7861 7861 + self.inner 7862 7862 + .ready() 7863 7863 + .await 7864 7864 + .map_err(|e| { 7865 7865 + tonic::Status::unknown( 7866 7866 + format!("Service was not ready: {}", e.into()), 7867 7867 + ) 7868 7868 + })?; 6809 7869 let codec = tonic::codec::ProstCodec::default(); 6810 6810 - let path = 6811 6811 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/GetPitch"); 7870 7870 + let path = http::uri::PathAndQuery::from_static( 7871 7871 + "/rockbox.v1alpha1.SoundService/GetPitch", 7872 7872 + ); 6812 7873 let mut req = request.into_request(); 6813 7874 req.extensions_mut() 6814 7875 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "GetPitch")); ··· 6817 7878 pub async fn set_pitch( 6818 7879 &mut self, 6819 7880 request: impl tonic::IntoRequest<super::SetPitchRequest>, 6820 6820 - ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status> { 6821 6821 - self.inner.ready().await.map_err(|e| { 6822 6822 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6823 6823 - })?; 7881 7881 + ) -> std::result::Result< 7882 7882 + tonic::Response<super::SetPitchResponse>, 7883 7883 + tonic::Status, 7884 7884 + > { 7885 7885 + self.inner 7886 7886 + .ready() 7887 7887 + .await 7888 7888 + .map_err(|e| { 7889 7889 + tonic::Status::unknown( 7890 7890 + format!("Service was not ready: {}", e.into()), 7891 7891 + ) 7892 7892 + })?; 6824 7893 let codec = tonic::codec::ProstCodec::default(); 6825 6825 - let path = 6826 6826 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SetPitch"); 7894 7894 + let path = http::uri::PathAndQuery::from_static( 7895 7895 + "/rockbox.v1alpha1.SoundService/SetPitch", 7896 7896 + ); 6827 7897 let mut req = request.into_request(); 6828 7898 req.extensions_mut() 6829 7899 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SetPitch")); ··· 6832 7902 pub async fn beep_play( 6833 7903 &mut self, 6834 7904 request: impl tonic::IntoRequest<super::BeepPlayRequest>, 6835 6835 - ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status> { 6836 6836 - self.inner.ready().await.map_err(|e| { 6837 6837 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6838 6838 - })?; 7905 7905 + ) -> std::result::Result< 7906 7906 + tonic::Response<super::BeepPlayResponse>, 7907 7907 + tonic::Status, 7908 7908 + > { 7909 7909 + self.inner 7910 7910 + .ready() 7911 7911 + .await 7912 7912 + .map_err(|e| { 7913 7913 + tonic::Status::unknown( 7914 7914 + format!("Service was not ready: {}", e.into()), 7915 7915 + ) 7916 7916 + })?; 6839 7917 let codec = tonic::codec::ProstCodec::default(); 6840 6840 - let path = 6841 6841 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/BeepPlay"); 7918 7918 + let path = http::uri::PathAndQuery::from_static( 7919 7919 + "/rockbox.v1alpha1.SoundService/BeepPlay", 7920 7920 + ); 6842 7921 let mut req = request.into_request(); 6843 7922 req.extensions_mut() 6844 7923 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "BeepPlay")); ··· 6847 7926 pub async fn pcmbuf_fade( 6848 7927 &mut self, 6849 7928 request: impl tonic::IntoRequest<super::PcmbufFadeRequest>, 6850 6850 - ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status> 6851 6851 - { 6852 6852 - self.inner.ready().await.map_err(|e| { 6853 6853 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6854 6854 - })?; 7929 7929 + ) -> std::result::Result< 7930 7930 + tonic::Response<super::PcmbufFadeResponse>, 7931 7931 + tonic::Status, 7932 7932 + > { 7933 7933 + self.inner 7934 7934 + .ready() 7935 7935 + .await 7936 7936 + .map_err(|e| { 7937 7937 + tonic::Status::unknown( 7938 7938 + format!("Service was not ready: {}", e.into()), 7939 7939 + ) 7940 7940 + })?; 6855 7941 let codec = tonic::codec::ProstCodec::default(); 6856 6856 - let path = 6857 6857 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/PcmbufFade"); 7942 7942 + let path = http::uri::PathAndQuery::from_static( 7943 7943 + "/rockbox.v1alpha1.SoundService/PcmbufFade", 7944 7944 + ); 6858 7945 let mut req = request.into_request(); 6859 6859 - req.extensions_mut().insert(GrpcMethod::new( 6860 6860 - "rockbox.v1alpha1.SoundService", 6861 6861 - "PcmbufFade", 6862 6862 - )); 7946 7946 + req.extensions_mut() 7947 7947 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "PcmbufFade")); 6863 7948 self.inner.unary(req, path, codec).await 6864 7949 } 6865 7950 pub async fn pcmbuf_set_low_latency( 6866 7951 &mut self, 6867 7952 request: impl tonic::IntoRequest<super::PcmbufSetLowLatencyRequest>, 6868 6868 - ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status> 6869 6869 - { 6870 6870 - self.inner.ready().await.map_err(|e| { 6871 6871 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6872 6872 - })?; 7953 7953 + ) -> std::result::Result< 7954 7954 + tonic::Response<super::PcmbufSetLowLatencyResponse>, 7955 7955 + tonic::Status, 7956 7956 + > { 7957 7957 + self.inner 7958 7958 + .ready() 7959 7959 + .await 7960 7960 + .map_err(|e| { 7961 7961 + tonic::Status::unknown( 7962 7962 + format!("Service was not ready: {}", e.into()), 7963 7963 + ) 7964 7964 + })?; 6873 7965 let codec = tonic::codec::ProstCodec::default(); 6874 7966 let path = http::uri::PathAndQuery::from_static( 6875 7967 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency", 6876 7968 ); 6877 7969 let mut req = request.into_request(); 6878 6878 - req.extensions_mut().insert(GrpcMethod::new( 6879 6879 - "rockbox.v1alpha1.SoundService", 6880 6880 - "PcmbufSetLowLatency", 6881 6881 - )); 7970 7970 + req.extensions_mut() 7971 7971 + .insert( 7972 7972 + GrpcMethod::new( 7973 7973 + "rockbox.v1alpha1.SoundService", 7974 7974 + "PcmbufSetLowLatency", 7975 7975 + ), 7976 7976 + ); 6882 7977 self.inner.unary(req, path, codec).await 6883 7978 } 6884 7979 pub async fn system_sound_play( 6885 7980 &mut self, 6886 7981 request: impl tonic::IntoRequest<super::SystemSoundPlayRequest>, 6887 6887 - ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status> 6888 6888 - { 6889 6889 - self.inner.ready().await.map_err(|e| { 6890 6890 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6891 6891 - })?; 7982 7982 + ) -> std::result::Result< 7983 7983 + tonic::Response<super::SystemSoundPlayResponse>, 7984 7984 + tonic::Status, 7985 7985 + > { 7986 7986 + self.inner 7987 7987 + .ready() 7988 7988 + .await 7989 7989 + .map_err(|e| { 7990 7990 + tonic::Status::unknown( 7991 7991 + format!("Service was not ready: {}", e.into()), 7992 7992 + ) 7993 7993 + })?; 6892 7994 let codec = tonic::codec::ProstCodec::default(); 6893 7995 let path = http::uri::PathAndQuery::from_static( 6894 7996 "/rockbox.v1alpha1.SoundService/SystemSoundPlay", 6895 7997 ); 6896 7998 let mut req = request.into_request(); 6897 6897 - req.extensions_mut().insert(GrpcMethod::new( 6898 6898 - "rockbox.v1alpha1.SoundService", 6899 6899 - "SystemSoundPlay", 6900 6900 - )); 7999 7999 + req.extensions_mut() 8000 8000 + .insert( 8001 8001 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SystemSoundPlay"), 8002 8002 + ); 6901 8003 self.inner.unary(req, path, codec).await 6902 8004 } 6903 8005 pub async fn keyclick_click( 6904 8006 &mut self, 6905 8007 request: impl tonic::IntoRequest<super::KeyclickClickRequest>, 6906 6906 - ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status> 6907 6907 - { 6908 6908 - self.inner.ready().await.map_err(|e| { 6909 6909 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6910 6910 - })?; 8008 8008 + ) -> std::result::Result< 8009 8009 + tonic::Response<super::KeyclickClickResponse>, 8010 8010 + tonic::Status, 8011 8011 + > { 8012 8012 + self.inner 8013 8013 + .ready() 8014 8014 + .await 8015 8015 + .map_err(|e| { 8016 8016 + tonic::Status::unknown( 8017 8017 + format!("Service was not ready: {}", e.into()), 8018 8018 + ) 8019 8019 + })?; 6911 8020 let codec = tonic::codec::ProstCodec::default(); 6912 8021 let path = http::uri::PathAndQuery::from_static( 6913 8022 "/rockbox.v1alpha1.SoundService/KeyclickClick", 6914 8023 ); 6915 8024 let mut req = request.into_request(); 6916 6916 - req.extensions_mut().insert(GrpcMethod::new( 6917 6917 - "rockbox.v1alpha1.SoundService", 6918 6918 - "KeyclickClick", 6919 6919 - )); 8025 8025 + req.extensions_mut() 8026 8026 + .insert( 8027 8027 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "KeyclickClick"), 8028 8028 + ); 6920 8029 self.inner.unary(req, path, codec).await 6921 8030 } 6922 8031 } ··· 6928 8037 dead_code, 6929 8038 missing_docs, 6930 8039 clippy::wildcard_imports, 6931 6931 - clippy::let_unit_value 8040 8040 + clippy::let_unit_value, 6932 8041 )] 6933 8042 use tonic::codegen::*; 6934 8043 /// Generated trait containing gRPC methods that should be implemented for use with SoundServiceServer. ··· 6937 8046 async fn adjust_volume( 6938 8047 &self, 6939 8048 request: tonic::Request<super::AdjustVolumeRequest>, 6940 6940 - ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status>; 8049 8049 + ) -> std::result::Result< 8050 8050 + tonic::Response<super::AdjustVolumeResponse>, 8051 8051 + tonic::Status, 8052 8052 + >; 6941 8053 async fn sound_set( 6942 8054 &self, 6943 8055 request: tonic::Request<super::SoundSetRequest>, 6944 6944 - ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status>; 8056 8056 + ) -> std::result::Result< 8057 8057 + tonic::Response<super::SoundSetResponse>, 8058 8058 + tonic::Status, 8059 8059 + >; 6945 8060 async fn sound_current( 6946 8061 &self, 6947 8062 request: tonic::Request<super::SoundCurrentRequest>, 6948 6948 - ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status>; 8063 8063 + ) -> std::result::Result< 8064 8064 + tonic::Response<super::SoundCurrentResponse>, 8065 8065 + tonic::Status, 8066 8066 + >; 6949 8067 async fn sound_default( 6950 8068 &self, 6951 8069 request: tonic::Request<super::SoundDefaultRequest>, 6952 6952 - ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status>; 8070 8070 + ) -> std::result::Result< 8071 8071 + tonic::Response<super::SoundDefaultResponse>, 8072 8072 + tonic::Status, 8073 8073 + >; 6953 8074 async fn sound_min( 6954 8075 &self, 6955 8076 request: tonic::Request<super::SoundMinRequest>, 6956 6956 - ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status>; 8077 8077 + ) -> std::result::Result< 8078 8078 + tonic::Response<super::SoundMinResponse>, 8079 8079 + tonic::Status, 8080 8080 + >; 6957 8081 async fn sound_max( 6958 8082 &self, 6959 8083 request: tonic::Request<super::SoundMaxRequest>, 6960 6960 - ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status>; 8084 8084 + ) -> std::result::Result< 8085 8085 + tonic::Response<super::SoundMaxResponse>, 8086 8086 + tonic::Status, 8087 8087 + >; 6961 8088 async fn sound_unit( 6962 8089 &self, 6963 8090 request: tonic::Request<super::SoundUnitRequest>, 6964 6964 - ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status>; 8091 8091 + ) -> std::result::Result< 8092 8092 + tonic::Response<super::SoundUnitResponse>, 8093 8093 + tonic::Status, 8094 8094 + >; 6965 8095 async fn sound_val2_phys( 6966 8096 &self, 6967 8097 request: tonic::Request<super::SoundVal2PhysRequest>, 6968 6968 - ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status>; 8098 8098 + ) -> std::result::Result< 8099 8099 + tonic::Response<super::SoundVal2PhysResponse>, 8100 8100 + tonic::Status, 8101 8101 + >; 6969 8102 async fn get_pitch( 6970 8103 &self, 6971 8104 request: tonic::Request<super::GetPitchRequest>, 6972 6972 - ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status>; 8105 8105 + ) -> std::result::Result< 8106 8106 + tonic::Response<super::GetPitchResponse>, 8107 8107 + tonic::Status, 8108 8108 + >; 6973 8109 async fn set_pitch( 6974 8110 &self, 6975 8111 request: tonic::Request<super::SetPitchRequest>, 6976 6976 - ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status>; 8112 8112 + ) -> std::result::Result< 8113 8113 + tonic::Response<super::SetPitchResponse>, 8114 8114 + tonic::Status, 8115 8115 + >; 6977 8116 async fn beep_play( 6978 8117 &self, 6979 8118 request: tonic::Request<super::BeepPlayRequest>, 6980 6980 - ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status>; 8119 8119 + ) -> std::result::Result< 8120 8120 + tonic::Response<super::BeepPlayResponse>, 8121 8121 + tonic::Status, 8122 8122 + >; 6981 8123 async fn pcmbuf_fade( 6982 8124 &self, 6983 8125 request: tonic::Request<super::PcmbufFadeRequest>, 6984 6984 - ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status>; 8126 8126 + ) -> std::result::Result< 8127 8127 + tonic::Response<super::PcmbufFadeResponse>, 8128 8128 + tonic::Status, 8129 8129 + >; 6985 8130 async fn pcmbuf_set_low_latency( 6986 8131 &self, 6987 8132 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 6988 6988 - ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status>; 8133 8133 + ) -> std::result::Result< 8134 8134 + tonic::Response<super::PcmbufSetLowLatencyResponse>, 8135 8135 + tonic::Status, 8136 8136 + >; 6989 8137 async fn system_sound_play( 6990 8138 &self, 6991 8139 request: tonic::Request<super::SystemSoundPlayRequest>, 6992 6992 - ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status>; 8140 8140 + ) -> std::result::Result< 8141 8141 + tonic::Response<super::SystemSoundPlayResponse>, 8142 8142 + tonic::Status, 8143 8143 + >; 6993 8144 async fn keyclick_click( 6994 8145 &self, 6995 8146 request: tonic::Request<super::KeyclickClickRequest>, 6996 6996 - ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>; 8147 8147 + ) -> std::result::Result< 8148 8148 + tonic::Response<super::KeyclickClickResponse>, 8149 8149 + tonic::Status, 8150 8150 + >; 6997 8151 } 6998 8152 #[derive(Debug)] 6999 8153 pub struct SoundServiceServer<T> { ··· 7016 8170 max_encoding_message_size: None, 7017 8171 } 7018 8172 } 7019 7019 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 8173 8173 + pub fn with_interceptor<F>( 8174 8174 + inner: T, 8175 8175 + interceptor: F, 8176 8176 + ) -> InterceptedService<Self, F> 7020 8177 where 7021 8178 F: tonic::service::Interceptor, 7022 8179 { ··· 7071 8228 "/rockbox.v1alpha1.SoundService/AdjustVolume" => { 7072 8229 #[allow(non_camel_case_types)] 7073 8230 struct AdjustVolumeSvc<T: SoundService>(pub Arc<T>); 7074 7074 - impl<T: SoundService> tonic::server::UnaryService<super::AdjustVolumeRequest> 7075 7075 - for AdjustVolumeSvc<T> 7076 7076 - { 8231 8231 + impl< 8232 8232 + T: SoundService, 8233 8233 + > tonic::server::UnaryService<super::AdjustVolumeRequest> 8234 8234 + for AdjustVolumeSvc<T> { 7077 8235 type Response = super::AdjustVolumeResponse; 7078 7078 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8236 8236 + type Future = BoxFuture< 8237 8237 + tonic::Response<Self::Response>, 8238 8238 + tonic::Status, 8239 8239 + >; 7079 8240 fn call( 7080 8241 &mut self, 7081 8242 request: tonic::Request<super::AdjustVolumeRequest>, ··· 7112 8273 "/rockbox.v1alpha1.SoundService/SoundSet" => { 7113 8274 #[allow(non_camel_case_types)] 7114 8275 struct SoundSetSvc<T: SoundService>(pub Arc<T>); 7115 7115 - impl<T: SoundService> tonic::server::UnaryService<super::SoundSetRequest> for SoundSetSvc<T> { 8276 8276 + impl< 8277 8277 + T: SoundService, 8278 8278 + > tonic::server::UnaryService<super::SoundSetRequest> 8279 8279 + for SoundSetSvc<T> { 7116 8280 type Response = super::SoundSetResponse; 7117 7117 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8281 8281 + type Future = BoxFuture< 8282 8282 + tonic::Response<Self::Response>, 8283 8283 + tonic::Status, 8284 8284 + >; 7118 8285 fn call( 7119 8286 &mut self, 7120 8287 request: tonic::Request<super::SoundSetRequest>, ··· 7151 8318 "/rockbox.v1alpha1.SoundService/SoundCurrent" => { 7152 8319 #[allow(non_camel_case_types)] 7153 8320 struct SoundCurrentSvc<T: SoundService>(pub Arc<T>); 7154 7154 - impl<T: SoundService> tonic::server::UnaryService<super::SoundCurrentRequest> 7155 7155 - for SoundCurrentSvc<T> 7156 7156 - { 8321 8321 + impl< 8322 8322 + T: SoundService, 8323 8323 + > tonic::server::UnaryService<super::SoundCurrentRequest> 8324 8324 + for SoundCurrentSvc<T> { 7157 8325 type Response = super::SoundCurrentResponse; 7158 7158 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8326 8326 + type Future = BoxFuture< 8327 8327 + tonic::Response<Self::Response>, 8328 8328 + tonic::Status, 8329 8329 + >; 7159 8330 fn call( 7160 8331 &mut self, 7161 8332 request: tonic::Request<super::SoundCurrentRequest>, ··· 7192 8363 "/rockbox.v1alpha1.SoundService/SoundDefault" => { 7193 8364 #[allow(non_camel_case_types)] 7194 8365 struct SoundDefaultSvc<T: SoundService>(pub Arc<T>); 7195 7195 - impl<T: SoundService> tonic::server::UnaryService<super::SoundDefaultRequest> 7196 7196 - for SoundDefaultSvc<T> 7197 7197 - { 8366 8366 + impl< 8367 8367 + T: SoundService, 8368 8368 + > tonic::server::UnaryService<super::SoundDefaultRequest> 8369 8369 + for SoundDefaultSvc<T> { 7198 8370 type Response = super::SoundDefaultResponse; 7199 7199 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8371 8371 + type Future = BoxFuture< 8372 8372 + tonic::Response<Self::Response>, 8373 8373 + tonic::Status, 8374 8374 + >; 7200 8375 fn call( 7201 8376 &mut self, 7202 8377 request: tonic::Request<super::SoundDefaultRequest>, ··· 7233 8408 "/rockbox.v1alpha1.SoundService/SoundMin" => { 7234 8409 #[allow(non_camel_case_types)] 7235 8410 struct SoundMinSvc<T: SoundService>(pub Arc<T>); 7236 7236 - impl<T: SoundService> tonic::server::UnaryService<super::SoundMinRequest> for SoundMinSvc<T> { 8411 8411 + impl< 8412 8412 + T: SoundService, 8413 8413 + > tonic::server::UnaryService<super::SoundMinRequest> 8414 8414 + for SoundMinSvc<T> { 7237 8415 type Response = super::SoundMinResponse; 7238 7238 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8416 8416 + type Future = BoxFuture< 8417 8417 + tonic::Response<Self::Response>, 8418 8418 + tonic::Status, 8419 8419 + >; 7239 8420 fn call( 7240 8421 &mut self, 7241 8422 request: tonic::Request<super::SoundMinRequest>, ··· 7272 8453 "/rockbox.v1alpha1.SoundService/SoundMax" => { 7273 8454 #[allow(non_camel_case_types)] 7274 8455 struct SoundMaxSvc<T: SoundService>(pub Arc<T>); 7275 7275 - impl<T: SoundService> tonic::server::UnaryService<super::SoundMaxRequest> for SoundMaxSvc<T> { 8456 8456 + impl< 8457 8457 + T: SoundService, 8458 8458 + > tonic::server::UnaryService<super::SoundMaxRequest> 8459 8459 + for SoundMaxSvc<T> { 7276 8460 type Response = super::SoundMaxResponse; 7277 7277 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8461 8461 + type Future = BoxFuture< 8462 8462 + tonic::Response<Self::Response>, 8463 8463 + tonic::Status, 8464 8464 + >; 7278 8465 fn call( 7279 8466 &mut self, 7280 8467 request: tonic::Request<super::SoundMaxRequest>, ··· 7311 8498 "/rockbox.v1alpha1.SoundService/SoundUnit" => { 7312 8499 #[allow(non_camel_case_types)] 7313 8500 struct SoundUnitSvc<T: SoundService>(pub Arc<T>); 7314 7314 - impl<T: SoundService> tonic::server::UnaryService<super::SoundUnitRequest> for SoundUnitSvc<T> { 8501 8501 + impl< 8502 8502 + T: SoundService, 8503 8503 + > tonic::server::UnaryService<super::SoundUnitRequest> 8504 8504 + for SoundUnitSvc<T> { 7315 8505 type Response = super::SoundUnitResponse; 7316 7316 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8506 8506 + type Future = BoxFuture< 8507 8507 + tonic::Response<Self::Response>, 8508 8508 + tonic::Status, 8509 8509 + >; 7317 8510 fn call( 7318 8511 &mut self, 7319 8512 request: tonic::Request<super::SoundUnitRequest>, ··· 7350 8543 "/rockbox.v1alpha1.SoundService/SoundVal2Phys" => { 7351 8544 #[allow(non_camel_case_types)] 7352 8545 struct SoundVal2PhysSvc<T: SoundService>(pub Arc<T>); 7353 7353 - impl<T: SoundService> tonic::server::UnaryService<super::SoundVal2PhysRequest> 7354 7354 - for SoundVal2PhysSvc<T> 7355 7355 - { 8546 8546 + impl< 8547 8547 + T: SoundService, 8548 8548 + > tonic::server::UnaryService<super::SoundVal2PhysRequest> 8549 8549 + for SoundVal2PhysSvc<T> { 7356 8550 type Response = super::SoundVal2PhysResponse; 7357 7357 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8551 8551 + type Future = BoxFuture< 8552 8552 + tonic::Response<Self::Response>, 8553 8553 + tonic::Status, 8554 8554 + >; 7358 8555 fn call( 7359 8556 &mut self, 7360 8557 request: tonic::Request<super::SoundVal2PhysRequest>, ··· 7391 8588 "/rockbox.v1alpha1.SoundService/GetPitch" => { 7392 8589 #[allow(non_camel_case_types)] 7393 8590 struct GetPitchSvc<T: SoundService>(pub Arc<T>); 7394 7394 - impl<T: SoundService> tonic::server::UnaryService<super::GetPitchRequest> for GetPitchSvc<T> { 8591 8591 + impl< 8592 8592 + T: SoundService, 8593 8593 + > tonic::server::UnaryService<super::GetPitchRequest> 8594 8594 + for GetPitchSvc<T> { 7395 8595 type Response = super::GetPitchResponse; 7396 7396 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8596 8596 + type Future = BoxFuture< 8597 8597 + tonic::Response<Self::Response>, 8598 8598 + tonic::Status, 8599 8599 + >; 7397 8600 fn call( 7398 8601 &mut self, 7399 8602 request: tonic::Request<super::GetPitchRequest>, ··· 7430 8633 "/rockbox.v1alpha1.SoundService/SetPitch" => { 7431 8634 #[allow(non_camel_case_types)] 7432 8635 struct SetPitchSvc<T: SoundService>(pub Arc<T>); 7433 7433 - impl<T: SoundService> tonic::server::UnaryService<super::SetPitchRequest> for SetPitchSvc<T> { 8636 8636 + impl< 8637 8637 + T: SoundService, 8638 8638 + > tonic::server::UnaryService<super::SetPitchRequest> 8639 8639 + for SetPitchSvc<T> { 7434 8640 type Response = super::SetPitchResponse; 7435 7435 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8641 8641 + type Future = BoxFuture< 8642 8642 + tonic::Response<Self::Response>, 8643 8643 + tonic::Status, 8644 8644 + >; 7436 8645 fn call( 7437 8646 &mut self, 7438 8647 request: tonic::Request<super::SetPitchRequest>, ··· 7469 8678 "/rockbox.v1alpha1.SoundService/BeepPlay" => { 7470 8679 #[allow(non_camel_case_types)] 7471 8680 struct BeepPlaySvc<T: SoundService>(pub Arc<T>); 7472 7472 - impl<T: SoundService> tonic::server::UnaryService<super::BeepPlayRequest> for BeepPlaySvc<T> { 8681 8681 + impl< 8682 8682 + T: SoundService, 8683 8683 + > tonic::server::UnaryService<super::BeepPlayRequest> 8684 8684 + for BeepPlaySvc<T> { 7473 8685 type Response = super::BeepPlayResponse; 7474 7474 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8686 8686 + type Future = BoxFuture< 8687 8687 + tonic::Response<Self::Response>, 8688 8688 + tonic::Status, 8689 8689 + >; 7475 8690 fn call( 7476 8691 &mut self, 7477 8692 request: tonic::Request<super::BeepPlayRequest>, ··· 7508 8723 "/rockbox.v1alpha1.SoundService/PcmbufFade" => { 7509 8724 #[allow(non_camel_case_types)] 7510 8725 struct PcmbufFadeSvc<T: SoundService>(pub Arc<T>); 7511 7511 - impl<T: SoundService> tonic::server::UnaryService<super::PcmbufFadeRequest> for PcmbufFadeSvc<T> { 8726 8726 + impl< 8727 8727 + T: SoundService, 8728 8728 + > tonic::server::UnaryService<super::PcmbufFadeRequest> 8729 8729 + for PcmbufFadeSvc<T> { 7512 8730 type Response = super::PcmbufFadeResponse; 7513 7513 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8731 8731 + type Future = BoxFuture< 8732 8732 + tonic::Response<Self::Response>, 8733 8733 + tonic::Status, 8734 8734 + >; 7514 8735 fn call( 7515 8736 &mut self, 7516 8737 request: tonic::Request<super::PcmbufFadeRequest>, ··· 7547 8768 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency" => { 7548 8769 #[allow(non_camel_case_types)] 7549 8770 struct PcmbufSetLowLatencySvc<T: SoundService>(pub Arc<T>); 7550 7550 - impl<T: SoundService> 7551 7551 - tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 7552 7552 - for PcmbufSetLowLatencySvc<T> 7553 7553 - { 8771 8771 + impl< 8772 8772 + T: SoundService, 8773 8773 + > tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 8774 8774 + for PcmbufSetLowLatencySvc<T> { 7554 8775 type Response = super::PcmbufSetLowLatencyResponse; 7555 7555 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8776 8776 + type Future = BoxFuture< 8777 8777 + tonic::Response<Self::Response>, 8778 8778 + tonic::Status, 8779 8779 + >; 7556 8780 fn call( 7557 8781 &mut self, 7558 8782 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 7559 8783 ) -> Self::Future { 7560 8784 let inner = Arc::clone(&self.0); 7561 8785 let fut = async move { 7562 7562 - <T as SoundService>::pcmbuf_set_low_latency(&inner, request).await 8786 8786 + <T as SoundService>::pcmbuf_set_low_latency(&inner, request) 8787 8787 + .await 7563 8788 }; 7564 8789 Box::pin(fut) 7565 8790 } ··· 7589 8814 "/rockbox.v1alpha1.SoundService/SystemSoundPlay" => { 7590 8815 #[allow(non_camel_case_types)] 7591 8816 struct SystemSoundPlaySvc<T: SoundService>(pub Arc<T>); 7592 7592 - impl<T: SoundService> tonic::server::UnaryService<super::SystemSoundPlayRequest> 7593 7593 - for SystemSoundPlaySvc<T> 7594 7594 - { 8817 8817 + impl< 8818 8818 + T: SoundService, 8819 8819 + > tonic::server::UnaryService<super::SystemSoundPlayRequest> 8820 8820 + for SystemSoundPlaySvc<T> { 7595 8821 type Response = super::SystemSoundPlayResponse; 7596 7596 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8822 8822 + type Future = BoxFuture< 8823 8823 + tonic::Response<Self::Response>, 8824 8824 + tonic::Status, 8825 8825 + >; 7597 8826 fn call( 7598 8827 &mut self, 7599 8828 request: tonic::Request<super::SystemSoundPlayRequest>, 7600 8829 ) -> Self::Future { 7601 8830 let inner = Arc::clone(&self.0); 7602 8831 let fut = async move { 7603 7603 - <T as SoundService>::system_sound_play(&inner, request).await 8832 8832 + <T as SoundService>::system_sound_play(&inner, request) 8833 8833 + .await 7604 8834 }; 7605 8835 Box::pin(fut) 7606 8836 } ··· 7630 8860 "/rockbox.v1alpha1.SoundService/KeyclickClick" => { 7631 8861 #[allow(non_camel_case_types)] 7632 8862 struct KeyclickClickSvc<T: SoundService>(pub Arc<T>); 7633 7633 - impl<T: SoundService> tonic::server::UnaryService<super::KeyclickClickRequest> 7634 7634 - for KeyclickClickSvc<T> 7635 7635 - { 8863 8863 + impl< 8864 8864 + T: SoundService, 8865 8865 + > tonic::server::UnaryService<super::KeyclickClickRequest> 8866 8866 + for KeyclickClickSvc<T> { 7636 8867 type Response = super::KeyclickClickResponse; 7637 7637 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8868 8868 + type Future = BoxFuture< 8869 8869 + tonic::Response<Self::Response>, 8870 8870 + tonic::Status, 8871 8871 + >; 7638 8872 fn call( 7639 8873 &mut self, 7640 8874 request: tonic::Request<super::KeyclickClickRequest>, ··· 7668 8902 }; 7669 8903 Box::pin(fut) 7670 8904 } 7671 7671 - _ => Box::pin(async move { 7672 7672 - let mut response = http::Response::new(empty_body()); 7673 7673 - let headers = response.headers_mut(); 7674 7674 - headers.insert( 7675 7675 - tonic::Status::GRPC_STATUS, 7676 7676 - (tonic::Code::Unimplemented as i32).into(), 7677 7677 - ); 7678 7678 - headers.insert( 7679 7679 - http::header::CONTENT_TYPE, 7680 7680 - tonic::metadata::GRPC_CONTENT_TYPE, 7681 7681 - ); 7682 7682 - Ok(response) 7683 7683 - }), 8905 8905 + _ => { 8906 8906 + Box::pin(async move { 8907 8907 + let mut response = http::Response::new(empty_body()); 8908 8908 + let headers = response.headers_mut(); 8909 8909 + headers 8910 8910 + .insert( 8911 8911 + tonic::Status::GRPC_STATUS, 8912 8912 + (tonic::Code::Unimplemented as i32).into(), 8913 8913 + ); 8914 8914 + headers 8915 8915 + .insert( 8916 8916 + http::header::CONTENT_TYPE, 8917 8917 + tonic::metadata::GRPC_CONTENT_TYPE, 8918 8918 + ); 8919 8919 + Ok(response) 8920 8920 + }) 8921 8921 + } 7684 8922 } 7685 8923 } 7686 8924 } ··· 7741 8979 dead_code, 7742 8980 missing_docs, 7743 8981 clippy::wildcard_imports, 7744 7744 - clippy::let_unit_value 8982 8982 + clippy::let_unit_value, 7745 8983 )] 7746 7746 - use tonic::codegen::http::Uri; 7747 8984 use tonic::codegen::*; 8985 8985 + use tonic::codegen::http::Uri; 7748 8986 #[derive(Debug, Clone)] 7749 8987 pub struct SystemServiceClient<T> { 7750 8988 inner: tonic::client::Grpc<T>, ··· 7788 9026 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 7789 9027 >, 7790 9028 >, 7791 7791 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 7792 7792 - Into<StdError> + std::marker::Send + std::marker::Sync, 9029 9029 + <T as tonic::codegen::Service< 9030 9030 + http::Request<tonic::body::BoxBody>, 9031 9031 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 7793 9032 { 7794 9033 SystemServiceClient::new(InterceptedService::new(inner, interceptor)) 7795 9034 } ··· 7827 9066 pub async fn get_rockbox_version( 7828 9067 &mut self, 7829 9068 request: impl tonic::IntoRequest<super::GetRockboxVersionRequest>, 7830 7830 - ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status> 7831 7831 - { 7832 7832 - self.inner.ready().await.map_err(|e| { 7833 7833 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7834 7834 - })?; 9069 9069 + ) -> std::result::Result< 9070 9070 + tonic::Response<super::GetRockboxVersionResponse>, 9071 9071 + tonic::Status, 9072 9072 + > { 9073 9073 + self.inner 9074 9074 + .ready() 9075 9075 + .await 9076 9076 + .map_err(|e| { 9077 9077 + tonic::Status::unknown( 9078 9078 + format!("Service was not ready: {}", e.into()), 9079 9079 + ) 9080 9080 + })?; 7835 9081 let codec = tonic::codec::ProstCodec::default(); 7836 9082 let path = http::uri::PathAndQuery::from_static( 7837 9083 "/rockbox.v1alpha1.SystemService/GetRockboxVersion", 7838 9084 ); 7839 9085 let mut req = request.into_request(); 7840 7840 - req.extensions_mut().insert(GrpcMethod::new( 7841 7841 - "rockbox.v1alpha1.SystemService", 7842 7842 - "GetRockboxVersion", 7843 7843 - )); 9086 9086 + req.extensions_mut() 9087 9087 + .insert( 9088 9088 + GrpcMethod::new( 9089 9089 + "rockbox.v1alpha1.SystemService", 9090 9090 + "GetRockboxVersion", 9091 9091 + ), 9092 9092 + ); 7844 9093 self.inner.unary(req, path, codec).await 7845 9094 } 7846 9095 pub async fn get_global_status( 7847 9096 &mut self, 7848 9097 request: impl tonic::IntoRequest<super::GetGlobalStatusRequest>, 7849 7849 - ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status> 7850 7850 - { 7851 7851 - self.inner.ready().await.map_err(|e| { 7852 7852 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7853 7853 - })?; 9098 9098 + ) -> std::result::Result< 9099 9099 + tonic::Response<super::GetGlobalStatusResponse>, 9100 9100 + tonic::Status, 9101 9101 + > { 9102 9102 + self.inner 9103 9103 + .ready() 9104 9104 + .await 9105 9105 + .map_err(|e| { 9106 9106 + tonic::Status::unknown( 9107 9107 + format!("Service was not ready: {}", e.into()), 9108 9108 + ) 9109 9109 + })?; 7854 9110 let codec = tonic::codec::ProstCodec::default(); 7855 9111 let path = http::uri::PathAndQuery::from_static( 7856 9112 "/rockbox.v1alpha1.SystemService/GetGlobalStatus", 7857 9113 ); 7858 9114 let mut req = request.into_request(); 7859 7859 - req.extensions_mut().insert(GrpcMethod::new( 7860 7860 - "rockbox.v1alpha1.SystemService", 7861 7861 - "GetGlobalStatus", 7862 7862 - )); 9115 9115 + req.extensions_mut() 9116 9116 + .insert( 9117 9117 + GrpcMethod::new("rockbox.v1alpha1.SystemService", "GetGlobalStatus"), 9118 9118 + ); 7863 9119 self.inner.unary(req, path, codec).await 7864 9120 } 7865 9121 } ··· 7871 9127 dead_code, 7872 9128 missing_docs, 7873 9129 clippy::wildcard_imports, 7874 7874 - clippy::let_unit_value 9130 9130 + clippy::let_unit_value, 7875 9131 )] 7876 9132 use tonic::codegen::*; 7877 9133 /// Generated trait containing gRPC methods that should be implemented for use with SystemServiceServer. ··· 7880 9136 async fn get_rockbox_version( 7881 9137 &self, 7882 9138 request: tonic::Request<super::GetRockboxVersionRequest>, 7883 7883 - ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status>; 9139 9139 + ) -> std::result::Result< 9140 9140 + tonic::Response<super::GetRockboxVersionResponse>, 9141 9141 + tonic::Status, 9142 9142 + >; 7884 9143 async fn get_global_status( 7885 9144 &self, 7886 9145 request: tonic::Request<super::GetGlobalStatusRequest>, 7887 7887 - ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>; 9146 9146 + ) -> std::result::Result< 9147 9147 + tonic::Response<super::GetGlobalStatusResponse>, 9148 9148 + tonic::Status, 9149 9149 + >; 7888 9150 } 7889 9151 #[derive(Debug)] 7890 9152 pub struct SystemServiceServer<T> { ··· 7907 9169 max_encoding_message_size: None, 7908 9170 } 7909 9171 } 7910 7910 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 9172 9172 + pub fn with_interceptor<F>( 9173 9173 + inner: T, 9174 9174 + interceptor: F, 9175 9175 + ) -> InterceptedService<Self, F> 7911 9176 where 7912 9177 F: tonic::service::Interceptor, 7913 9178 { ··· 7962 9227 "/rockbox.v1alpha1.SystemService/GetRockboxVersion" => { 7963 9228 #[allow(non_camel_case_types)] 7964 9229 struct GetRockboxVersionSvc<T: SystemService>(pub Arc<T>); 7965 7965 - impl<T: SystemService> 7966 7966 - tonic::server::UnaryService<super::GetRockboxVersionRequest> 7967 7967 - for GetRockboxVersionSvc<T> 7968 7968 - { 9230 9230 + impl< 9231 9231 + T: SystemService, 9232 9232 + > tonic::server::UnaryService<super::GetRockboxVersionRequest> 9233 9233 + for GetRockboxVersionSvc<T> { 7969 9234 type Response = super::GetRockboxVersionResponse; 7970 7970 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9235 9235 + type Future = BoxFuture< 9236 9236 + tonic::Response<Self::Response>, 9237 9237 + tonic::Status, 9238 9238 + >; 7971 9239 fn call( 7972 9240 &mut self, 7973 9241 request: tonic::Request<super::GetRockboxVersionRequest>, 7974 9242 ) -> Self::Future { 7975 9243 let inner = Arc::clone(&self.0); 7976 9244 let fut = async move { 7977 7977 - <T as SystemService>::get_rockbox_version(&inner, request).await 9245 9245 + <T as SystemService>::get_rockbox_version(&inner, request) 9246 9246 + .await 7978 9247 }; 7979 9248 Box::pin(fut) 7980 9249 } ··· 8004 9273 "/rockbox.v1alpha1.SystemService/GetGlobalStatus" => { 8005 9274 #[allow(non_camel_case_types)] 8006 9275 struct GetGlobalStatusSvc<T: SystemService>(pub Arc<T>); 8007 8007 - impl<T: SystemService> 8008 8008 - tonic::server::UnaryService<super::GetGlobalStatusRequest> 8009 8009 - for GetGlobalStatusSvc<T> 8010 8010 - { 9276 9276 + impl< 9277 9277 + T: SystemService, 9278 9278 + > tonic::server::UnaryService<super::GetGlobalStatusRequest> 9279 9279 + for GetGlobalStatusSvc<T> { 8011 9280 type Response = super::GetGlobalStatusResponse; 8012 8012 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9281 9281 + type Future = BoxFuture< 9282 9282 + tonic::Response<Self::Response>, 9283 9283 + tonic::Status, 9284 9284 + >; 8013 9285 fn call( 8014 9286 &mut self, 8015 9287 request: tonic::Request<super::GetGlobalStatusRequest>, 8016 9288 ) -> Self::Future { 8017 9289 let inner = Arc::clone(&self.0); 8018 9290 let fut = async move { 8019 8019 - <T as SystemService>::get_global_status(&inner, request).await 9291 9291 + <T as SystemService>::get_global_status(&inner, request) 9292 9292 + .await 8020 9293 }; 8021 9294 Box::pin(fut) 8022 9295 } ··· 8043 9316 }; 8044 9317 Box::pin(fut) 8045 9318 } 8046 8046 - _ => Box::pin(async move { 8047 8047 - let mut response = http::Response::new(empty_body()); 8048 8048 - let headers = response.headers_mut(); 8049 8049 - headers.insert( 8050 8050 - tonic::Status::GRPC_STATUS, 8051 8051 - (tonic::Code::Unimplemented as i32).into(), 8052 8052 - ); 8053 8053 - headers.insert( 8054 8054 - http::header::CONTENT_TYPE, 8055 8055 - tonic::metadata::GRPC_CONTENT_TYPE, 8056 8056 - ); 8057 8057 - Ok(response) 8058 8058 - }), 9319 9319 + _ => { 9320 9320 + Box::pin(async move { 9321 9321 + let mut response = http::Response::new(empty_body()); 9322 9322 + let headers = response.headers_mut(); 9323 9323 + headers 9324 9324 + .insert( 9325 9325 + tonic::Status::GRPC_STATUS, 9326 9326 + (tonic::Code::Unimplemented as i32).into(), 9327 9327 + ); 9328 9328 + headers 9329 9329 + .insert( 9330 9330 + http::header::CONTENT_TYPE, 9331 9331 + tonic::metadata::GRPC_CONTENT_TYPE, 9332 9332 + ); 9333 9333 + Ok(response) 9334 9334 + }) 9335 9335 + } 8059 9336 } 8060 9337 } 8061 9338 }

+3491 -1725

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

reviewed

··· 43 43 dead_code, 44 44 missing_docs, 45 45 clippy::wildcard_imports, 46 46 - clippy::let_unit_value 46 46 + clippy::let_unit_value, 47 47 )] 48 48 - use tonic::codegen::http::Uri; 49 48 use tonic::codegen::*; 49 49 + use tonic::codegen::http::Uri; 50 50 #[derive(Debug, Clone)] 51 51 pub struct BrowseServiceClient<T> { 52 52 inner: tonic::client::Grpc<T>, ··· 90 90 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 91 91 >, 92 92 >, 93 93 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 94 94 - Into<StdError> + std::marker::Send + std::marker::Sync, 93 93 + <T as tonic::codegen::Service< 94 94 + http::Request<tonic::body::BoxBody>, 95 95 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 95 96 { 96 97 BrowseServiceClient::new(InterceptedService::new(inner, interceptor)) 97 98 } ··· 129 130 pub async fn tree_get_entries( 130 131 &mut self, 131 132 request: impl tonic::IntoRequest<super::TreeGetEntriesRequest>, 132 132 - ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status> 133 133 - { 134 134 - self.inner.ready().await.map_err(|e| { 135 135 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 136 136 - })?; 133 133 + ) -> std::result::Result< 134 134 + tonic::Response<super::TreeGetEntriesResponse>, 135 135 + tonic::Status, 136 136 + > { 137 137 + self.inner 138 138 + .ready() 139 139 + .await 140 140 + .map_err(|e| { 141 141 + tonic::Status::unknown( 142 142 + format!("Service was not ready: {}", e.into()), 143 143 + ) 144 144 + })?; 137 145 let codec = tonic::codec::ProstCodec::default(); 138 146 let path = http::uri::PathAndQuery::from_static( 139 147 "/rockbox.v1alpha1.BrowseService/TreeGetEntries", 140 148 ); 141 149 let mut req = request.into_request(); 142 142 - req.extensions_mut().insert(GrpcMethod::new( 143 143 - "rockbox.v1alpha1.BrowseService", 144 144 - "TreeGetEntries", 145 145 - )); 150 150 + req.extensions_mut() 151 151 + .insert( 152 152 + GrpcMethod::new("rockbox.v1alpha1.BrowseService", "TreeGetEntries"), 153 153 + ); 146 154 self.inner.unary(req, path, codec).await 147 155 } 148 156 } ··· 154 162 dead_code, 155 163 missing_docs, 156 164 clippy::wildcard_imports, 157 157 - clippy::let_unit_value 165 165 + clippy::let_unit_value, 158 166 )] 159 167 use tonic::codegen::*; 160 168 /// Generated trait containing gRPC methods that should be implemented for use with BrowseServiceServer. ··· 163 171 async fn tree_get_entries( 164 172 &self, 165 173 request: tonic::Request<super::TreeGetEntriesRequest>, 166 166 - ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status>; 174 174 + ) -> std::result::Result< 175 175 + tonic::Response<super::TreeGetEntriesResponse>, 176 176 + tonic::Status, 177 177 + >; 167 178 } 168 179 #[derive(Debug)] 169 180 pub struct BrowseServiceServer<T> { ··· 186 197 max_encoding_message_size: None, 187 198 } 188 199 } 189 189 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 200 200 + pub fn with_interceptor<F>( 201 201 + inner: T, 202 202 + interceptor: F, 203 203 + ) -> InterceptedService<Self, F> 190 204 where 191 205 F: tonic::service::Interceptor, 192 206 { ··· 241 255 "/rockbox.v1alpha1.BrowseService/TreeGetEntries" => { 242 256 #[allow(non_camel_case_types)] 243 257 struct TreeGetEntriesSvc<T: BrowseService>(pub Arc<T>); 244 244 - impl<T: BrowseService> tonic::server::UnaryService<super::TreeGetEntriesRequest> 245 245 - for TreeGetEntriesSvc<T> 246 246 - { 258 258 + impl< 259 259 + T: BrowseService, 260 260 + > tonic::server::UnaryService<super::TreeGetEntriesRequest> 261 261 + for TreeGetEntriesSvc<T> { 247 262 type Response = super::TreeGetEntriesResponse; 248 248 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 263 263 + type Future = BoxFuture< 264 264 + tonic::Response<Self::Response>, 265 265 + tonic::Status, 266 266 + >; 249 267 fn call( 250 268 &mut self, 251 269 request: tonic::Request<super::TreeGetEntriesRequest>, 252 270 ) -> Self::Future { 253 271 let inner = Arc::clone(&self.0); 254 272 let fut = async move { 255 255 - <T as BrowseService>::tree_get_entries(&inner, request).await 273 273 + <T as BrowseService>::tree_get_entries(&inner, request) 274 274 + .await 256 275 }; 257 276 Box::pin(fut) 258 277 } ··· 279 298 }; 280 299 Box::pin(fut) 281 300 } 282 282 - _ => Box::pin(async move { 283 283 - let mut response = http::Response::new(empty_body()); 284 284 - let headers = response.headers_mut(); 285 285 - headers.insert( 286 286 - tonic::Status::GRPC_STATUS, 287 287 - (tonic::Code::Unimplemented as i32).into(), 288 288 - ); 289 289 - headers.insert( 290 290 - http::header::CONTENT_TYPE, 291 291 - tonic::metadata::GRPC_CONTENT_TYPE, 292 292 - ); 293 293 - Ok(response) 294 294 - }), 301 301 + _ => { 302 302 + Box::pin(async move { 303 303 + let mut response = http::Response::new(empty_body()); 304 304 + let headers = response.headers_mut(); 305 305 + headers 306 306 + .insert( 307 307 + tonic::Status::GRPC_STATUS, 308 308 + (tonic::Code::Unimplemented as i32).into(), 309 309 + ); 310 310 + headers 311 311 + .insert( 312 312 + http::header::CONTENT_TYPE, 313 313 + tonic::metadata::GRPC_CONTENT_TYPE, 314 314 + ); 315 315 + Ok(response) 316 316 + }) 317 317 + } 295 318 } 296 319 } 297 320 } ··· 384 407 dead_code, 385 408 missing_docs, 386 409 clippy::wildcard_imports, 387 387 - clippy::let_unit_value 410 410 + clippy::let_unit_value, 388 411 )] 389 389 - use tonic::codegen::http::Uri; 390 412 use tonic::codegen::*; 413 413 + use tonic::codegen::http::Uri; 391 414 #[derive(Debug, Clone)] 392 415 pub struct DeviceServiceClient<T> { 393 416 inner: tonic::client::Grpc<T>, ··· 431 454 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 432 455 >, 433 456 >, 434 434 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 435 435 - Into<StdError> + std::marker::Send + std::marker::Sync, 457 457 + <T as tonic::codegen::Service< 458 458 + http::Request<tonic::body::BoxBody>, 459 459 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 436 460 { 437 461 DeviceServiceClient::new(InterceptedService::new(inner, interceptor)) 438 462 } ··· 470 494 pub async fn get_devices( 471 495 &mut self, 472 496 request: impl tonic::IntoRequest<super::GetDevicesRequest>, 473 473 - ) -> std::result::Result<tonic::Response<super::GetDevicesResponse>, tonic::Status> 474 474 - { 475 475 - self.inner.ready().await.map_err(|e| { 476 476 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 477 477 - })?; 497 497 + ) -> std::result::Result< 498 498 + tonic::Response<super::GetDevicesResponse>, 499 499 + tonic::Status, 500 500 + > { 501 501 + self.inner 502 502 + .ready() 503 503 + .await 504 504 + .map_err(|e| { 505 505 + tonic::Status::unknown( 506 506 + format!("Service was not ready: {}", e.into()), 507 507 + ) 508 508 + })?; 478 509 let codec = tonic::codec::ProstCodec::default(); 479 479 - let path = 480 480 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.DeviceService/GetDevices"); 510 510 + let path = http::uri::PathAndQuery::from_static( 511 511 + "/rockbox.v1alpha1.DeviceService/GetDevices", 512 512 + ); 481 513 let mut req = request.into_request(); 482 482 - req.extensions_mut().insert(GrpcMethod::new( 483 483 - "rockbox.v1alpha1.DeviceService", 484 484 - "GetDevices", 485 485 - )); 514 514 + req.extensions_mut() 515 515 + .insert(GrpcMethod::new("rockbox.v1alpha1.DeviceService", "GetDevices")); 486 516 self.inner.unary(req, path, codec).await 487 517 } 488 518 pub async fn get_device( 489 519 &mut self, 490 520 request: impl tonic::IntoRequest<super::GetDeviceRequest>, 491 491 - ) -> std::result::Result<tonic::Response<super::GetDeviceResponse>, tonic::Status> { 492 492 - self.inner.ready().await.map_err(|e| { 493 493 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 494 494 - })?; 521 521 + ) -> std::result::Result< 522 522 + tonic::Response<super::GetDeviceResponse>, 523 523 + tonic::Status, 524 524 + > { 525 525 + self.inner 526 526 + .ready() 527 527 + .await 528 528 + .map_err(|e| { 529 529 + tonic::Status::unknown( 530 530 + format!("Service was not ready: {}", e.into()), 531 531 + ) 532 532 + })?; 495 533 let codec = tonic::codec::ProstCodec::default(); 496 496 - let path = 497 497 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.DeviceService/GetDevice"); 534 534 + let path = http::uri::PathAndQuery::from_static( 535 535 + "/rockbox.v1alpha1.DeviceService/GetDevice", 536 536 + ); 498 537 let mut req = request.into_request(); 499 499 - req.extensions_mut().insert(GrpcMethod::new( 500 500 - "rockbox.v1alpha1.DeviceService", 501 501 - "GetDevice", 502 502 - )); 538 538 + req.extensions_mut() 539 539 + .insert(GrpcMethod::new("rockbox.v1alpha1.DeviceService", "GetDevice")); 503 540 self.inner.unary(req, path, codec).await 504 541 } 505 542 pub async fn connect_device( 506 543 &mut self, 507 544 request: impl tonic::IntoRequest<super::ConnectDeviceRequest>, 508 508 - ) -> std::result::Result<tonic::Response<super::ConnectDeviceResponse>, tonic::Status> 509 509 - { 510 510 - self.inner.ready().await.map_err(|e| { 511 511 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 512 512 - })?; 545 545 + ) -> std::result::Result< 546 546 + tonic::Response<super::ConnectDeviceResponse>, 547 547 + tonic::Status, 548 548 + > { 549 549 + self.inner 550 550 + .ready() 551 551 + .await 552 552 + .map_err(|e| { 553 553 + tonic::Status::unknown( 554 554 + format!("Service was not ready: {}", e.into()), 555 555 + ) 556 556 + })?; 513 557 let codec = tonic::codec::ProstCodec::default(); 514 558 let path = http::uri::PathAndQuery::from_static( 515 559 "/rockbox.v1alpha1.DeviceService/ConnectDevice", 516 560 ); 517 561 let mut req = request.into_request(); 518 518 - req.extensions_mut().insert(GrpcMethod::new( 519 519 - "rockbox.v1alpha1.DeviceService", 520 520 - "ConnectDevice", 521 521 - )); 562 562 + req.extensions_mut() 563 563 + .insert( 564 564 + GrpcMethod::new("rockbox.v1alpha1.DeviceService", "ConnectDevice"), 565 565 + ); 522 566 self.inner.unary(req, path, codec).await 523 567 } 524 568 pub async fn disconnect_device( 525 569 &mut self, 526 570 request: impl tonic::IntoRequest<super::DisconnectDeviceRequest>, 527 527 - ) -> std::result::Result<tonic::Response<super::DisconnectDeviceResponse>, tonic::Status> 528 528 - { 529 529 - self.inner.ready().await.map_err(|e| { 530 530 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 531 531 - })?; 571 571 + ) -> std::result::Result< 572 572 + tonic::Response<super::DisconnectDeviceResponse>, 573 573 + tonic::Status, 574 574 + > { 575 575 + self.inner 576 576 + .ready() 577 577 + .await 578 578 + .map_err(|e| { 579 579 + tonic::Status::unknown( 580 580 + format!("Service was not ready: {}", e.into()), 581 581 + ) 582 582 + })?; 532 583 let codec = tonic::codec::ProstCodec::default(); 533 584 let path = http::uri::PathAndQuery::from_static( 534 585 "/rockbox.v1alpha1.DeviceService/DisconnectDevice", 535 586 ); 536 587 let mut req = request.into_request(); 537 537 - req.extensions_mut().insert(GrpcMethod::new( 538 538 - "rockbox.v1alpha1.DeviceService", 539 539 - "DisconnectDevice", 540 540 - )); 588 588 + req.extensions_mut() 589 589 + .insert( 590 590 + GrpcMethod::new("rockbox.v1alpha1.DeviceService", "DisconnectDevice"), 591 591 + ); 541 592 self.inner.unary(req, path, codec).await 542 593 } 543 594 } ··· 549 600 dead_code, 550 601 missing_docs, 551 602 clippy::wildcard_imports, 552 552 - clippy::let_unit_value 603 603 + clippy::let_unit_value, 553 604 )] 554 605 use tonic::codegen::*; 555 606 /// Generated trait containing gRPC methods that should be implemented for use with DeviceServiceServer. ··· 558 609 async fn get_devices( 559 610 &self, 560 611 request: tonic::Request<super::GetDevicesRequest>, 561 561 - ) -> std::result::Result<tonic::Response<super::GetDevicesResponse>, tonic::Status>; 612 612 + ) -> std::result::Result< 613 613 + tonic::Response<super::GetDevicesResponse>, 614 614 + tonic::Status, 615 615 + >; 562 616 async fn get_device( 563 617 &self, 564 618 request: tonic::Request<super::GetDeviceRequest>, 565 565 - ) -> std::result::Result<tonic::Response<super::GetDeviceResponse>, tonic::Status>; 619 619 + ) -> std::result::Result< 620 620 + tonic::Response<super::GetDeviceResponse>, 621 621 + tonic::Status, 622 622 + >; 566 623 async fn connect_device( 567 624 &self, 568 625 request: tonic::Request<super::ConnectDeviceRequest>, 569 569 - ) -> std::result::Result<tonic::Response<super::ConnectDeviceResponse>, tonic::Status>; 626 626 + ) -> std::result::Result< 627 627 + tonic::Response<super::ConnectDeviceResponse>, 628 628 + tonic::Status, 629 629 + >; 570 630 async fn disconnect_device( 571 631 &self, 572 632 request: tonic::Request<super::DisconnectDeviceRequest>, 573 573 - ) -> std::result::Result<tonic::Response<super::DisconnectDeviceResponse>, tonic::Status>; 633 633 + ) -> std::result::Result< 634 634 + tonic::Response<super::DisconnectDeviceResponse>, 635 635 + tonic::Status, 636 636 + >; 574 637 } 575 638 #[derive(Debug)] 576 639 pub struct DeviceServiceServer<T> { ··· 593 656 max_encoding_message_size: None, 594 657 } 595 658 } 596 596 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 659 659 + pub fn with_interceptor<F>( 660 660 + inner: T, 661 661 + interceptor: F, 662 662 + ) -> InterceptedService<Self, F> 597 663 where 598 664 F: tonic::service::Interceptor, 599 665 { ··· 648 714 "/rockbox.v1alpha1.DeviceService/GetDevices" => { 649 715 #[allow(non_camel_case_types)] 650 716 struct GetDevicesSvc<T: DeviceService>(pub Arc<T>); 651 651 - impl<T: DeviceService> tonic::server::UnaryService<super::GetDevicesRequest> for GetDevicesSvc<T> { 717 717 + impl< 718 718 + T: DeviceService, 719 719 + > tonic::server::UnaryService<super::GetDevicesRequest> 720 720 + for GetDevicesSvc<T> { 652 721 type Response = super::GetDevicesResponse; 653 653 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 722 722 + type Future = BoxFuture< 723 723 + tonic::Response<Self::Response>, 724 724 + tonic::Status, 725 725 + >; 654 726 fn call( 655 727 &mut self, 656 728 request: tonic::Request<super::GetDevicesRequest>, ··· 687 759 "/rockbox.v1alpha1.DeviceService/GetDevice" => { 688 760 #[allow(non_camel_case_types)] 689 761 struct GetDeviceSvc<T: DeviceService>(pub Arc<T>); 690 690 - impl<T: DeviceService> tonic::server::UnaryService<super::GetDeviceRequest> for GetDeviceSvc<T> { 762 762 + impl< 763 763 + T: DeviceService, 764 764 + > tonic::server::UnaryService<super::GetDeviceRequest> 765 765 + for GetDeviceSvc<T> { 691 766 type Response = super::GetDeviceResponse; 692 692 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 767 767 + type Future = BoxFuture< 768 768 + tonic::Response<Self::Response>, 769 769 + tonic::Status, 770 770 + >; 693 771 fn call( 694 772 &mut self, 695 773 request: tonic::Request<super::GetDeviceRequest>, ··· 726 804 "/rockbox.v1alpha1.DeviceService/ConnectDevice" => { 727 805 #[allow(non_camel_case_types)] 728 806 struct ConnectDeviceSvc<T: DeviceService>(pub Arc<T>); 729 729 - impl<T: DeviceService> tonic::server::UnaryService<super::ConnectDeviceRequest> 730 730 - for ConnectDeviceSvc<T> 731 731 - { 807 807 + impl< 808 808 + T: DeviceService, 809 809 + > tonic::server::UnaryService<super::ConnectDeviceRequest> 810 810 + for ConnectDeviceSvc<T> { 732 811 type Response = super::ConnectDeviceResponse; 733 733 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 812 812 + type Future = BoxFuture< 813 813 + tonic::Response<Self::Response>, 814 814 + tonic::Status, 815 815 + >; 734 816 fn call( 735 817 &mut self, 736 818 request: tonic::Request<super::ConnectDeviceRequest>, ··· 767 849 "/rockbox.v1alpha1.DeviceService/DisconnectDevice" => { 768 850 #[allow(non_camel_case_types)] 769 851 struct DisconnectDeviceSvc<T: DeviceService>(pub Arc<T>); 770 770 - impl<T: DeviceService> 771 771 - tonic::server::UnaryService<super::DisconnectDeviceRequest> 772 772 - for DisconnectDeviceSvc<T> 773 773 - { 852 852 + impl< 853 853 + T: DeviceService, 854 854 + > tonic::server::UnaryService<super::DisconnectDeviceRequest> 855 855 + for DisconnectDeviceSvc<T> { 774 856 type Response = super::DisconnectDeviceResponse; 775 775 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 857 857 + type Future = BoxFuture< 858 858 + tonic::Response<Self::Response>, 859 859 + tonic::Status, 860 860 + >; 776 861 fn call( 777 862 &mut self, 778 863 request: tonic::Request<super::DisconnectDeviceRequest>, 779 864 ) -> Self::Future { 780 865 let inner = Arc::clone(&self.0); 781 866 let fut = async move { 782 782 - <T as DeviceService>::disconnect_device(&inner, request).await 867 867 + <T as DeviceService>::disconnect_device(&inner, request) 868 868 + .await 783 869 }; 784 870 Box::pin(fut) 785 871 } ··· 806 892 }; 807 893 Box::pin(fut) 808 894 } 809 809 - _ => Box::pin(async move { 810 810 - let mut response = http::Response::new(empty_body()); 811 811 - let headers = response.headers_mut(); 812 812 - headers.insert( 813 813 - tonic::Status::GRPC_STATUS, 814 814 - (tonic::Code::Unimplemented as i32).into(), 815 815 - ); 816 816 - headers.insert( 817 817 - http::header::CONTENT_TYPE, 818 818 - tonic::metadata::GRPC_CONTENT_TYPE, 819 819 - ); 820 820 - Ok(response) 821 821 - }), 895 895 + _ => { 896 896 + Box::pin(async move { 897 897 + let mut response = http::Response::new(empty_body()); 898 898 + let headers = response.headers_mut(); 899 899 + headers 900 900 + .insert( 901 901 + tonic::Status::GRPC_STATUS, 902 902 + (tonic::Code::Unimplemented as i32).into(), 903 903 + ); 904 904 + headers 905 905 + .insert( 906 906 + http::header::CONTENT_TYPE, 907 907 + tonic::metadata::GRPC_CONTENT_TYPE, 908 908 + ); 909 909 + Ok(response) 910 910 + }) 911 911 + } 822 912 } 823 913 } 824 914 } ··· 1075 1165 dead_code, 1076 1166 missing_docs, 1077 1167 clippy::wildcard_imports, 1078 1078 - clippy::let_unit_value 1168 1168 + clippy::let_unit_value, 1079 1169 )] 1080 1080 - use tonic::codegen::http::Uri; 1081 1170 use tonic::codegen::*; 1171 1171 + use tonic::codegen::http::Uri; 1082 1172 #[derive(Debug, Clone)] 1083 1173 pub struct LibraryServiceClient<T> { 1084 1174 inner: tonic::client::Grpc<T>, ··· 1122 1212 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 1123 1213 >, 1124 1214 >, 1125 1125 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 1126 1126 - Into<StdError> + std::marker::Send + std::marker::Sync, 1215 1215 + <T as tonic::codegen::Service< 1216 1216 + http::Request<tonic::body::BoxBody>, 1217 1217 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 1127 1218 { 1128 1219 LibraryServiceClient::new(InterceptedService::new(inner, interceptor)) 1129 1220 } ··· 1161 1252 pub async fn get_albums( 1162 1253 &mut self, 1163 1254 request: impl tonic::IntoRequest<super::GetAlbumsRequest>, 1164 1164 - ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status> { 1165 1165 - self.inner.ready().await.map_err(|e| { 1166 1166 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1167 1167 - })?; 1255 1255 + ) -> std::result::Result< 1256 1256 + tonic::Response<super::GetAlbumsResponse>, 1257 1257 + tonic::Status, 1258 1258 + > { 1259 1259 + self.inner 1260 1260 + .ready() 1261 1261 + .await 1262 1262 + .map_err(|e| { 1263 1263 + tonic::Status::unknown( 1264 1264 + format!("Service was not ready: {}", e.into()), 1265 1265 + ) 1266 1266 + })?; 1168 1267 let codec = tonic::codec::ProstCodec::default(); 1169 1169 - let path = 1170 1170 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbums"); 1268 1268 + let path = http::uri::PathAndQuery::from_static( 1269 1269 + "/rockbox.v1alpha1.LibraryService/GetAlbums", 1270 1270 + ); 1171 1271 let mut req = request.into_request(); 1172 1172 - req.extensions_mut().insert(GrpcMethod::new( 1173 1173 - "rockbox.v1alpha1.LibraryService", 1174 1174 - "GetAlbums", 1175 1175 - )); 1272 1272 + req.extensions_mut() 1273 1273 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbums")); 1176 1274 self.inner.unary(req, path, codec).await 1177 1275 } 1178 1276 pub async fn get_artists( 1179 1277 &mut self, 1180 1278 request: impl tonic::IntoRequest<super::GetArtistsRequest>, 1181 1181 - ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status> 1182 1182 - { 1183 1183 - self.inner.ready().await.map_err(|e| { 1184 1184 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1185 1185 - })?; 1279 1279 + ) -> std::result::Result< 1280 1280 + tonic::Response<super::GetArtistsResponse>, 1281 1281 + tonic::Status, 1282 1282 + > { 1283 1283 + self.inner 1284 1284 + .ready() 1285 1285 + .await 1286 1286 + .map_err(|e| { 1287 1287 + tonic::Status::unknown( 1288 1288 + format!("Service was not ready: {}", e.into()), 1289 1289 + ) 1290 1290 + })?; 1186 1291 let codec = tonic::codec::ProstCodec::default(); 1187 1187 - let path = 1188 1188 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtists"); 1292 1292 + let path = http::uri::PathAndQuery::from_static( 1293 1293 + "/rockbox.v1alpha1.LibraryService/GetArtists", 1294 1294 + ); 1189 1295 let mut req = request.into_request(); 1190 1190 - req.extensions_mut().insert(GrpcMethod::new( 1191 1191 - "rockbox.v1alpha1.LibraryService", 1192 1192 - "GetArtists", 1193 1193 - )); 1296 1296 + req.extensions_mut() 1297 1297 + .insert( 1298 1298 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtists"), 1299 1299 + ); 1194 1300 self.inner.unary(req, path, codec).await 1195 1301 } 1196 1302 pub async fn get_tracks( 1197 1303 &mut self, 1198 1304 request: impl tonic::IntoRequest<super::GetTracksRequest>, 1199 1199 - ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status> { 1200 1200 - self.inner.ready().await.map_err(|e| { 1201 1201 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1202 1202 - })?; 1305 1305 + ) -> std::result::Result< 1306 1306 + tonic::Response<super::GetTracksResponse>, 1307 1307 + tonic::Status, 1308 1308 + > { 1309 1309 + self.inner 1310 1310 + .ready() 1311 1311 + .await 1312 1312 + .map_err(|e| { 1313 1313 + tonic::Status::unknown( 1314 1314 + format!("Service was not ready: {}", e.into()), 1315 1315 + ) 1316 1316 + })?; 1203 1317 let codec = tonic::codec::ProstCodec::default(); 1204 1204 - let path = 1205 1205 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTracks"); 1318 1318 + let path = http::uri::PathAndQuery::from_static( 1319 1319 + "/rockbox.v1alpha1.LibraryService/GetTracks", 1320 1320 + ); 1206 1321 let mut req = request.into_request(); 1207 1207 - req.extensions_mut().insert(GrpcMethod::new( 1208 1208 - "rockbox.v1alpha1.LibraryService", 1209 1209 - "GetTracks", 1210 1210 - )); 1322 1322 + req.extensions_mut() 1323 1323 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTracks")); 1211 1324 self.inner.unary(req, path, codec).await 1212 1325 } 1213 1326 pub async fn get_album( 1214 1327 &mut self, 1215 1328 request: impl tonic::IntoRequest<super::GetAlbumRequest>, 1216 1216 - ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status> { 1217 1217 - self.inner.ready().await.map_err(|e| { 1218 1218 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1219 1219 - })?; 1329 1329 + ) -> std::result::Result< 1330 1330 + tonic::Response<super::GetAlbumResponse>, 1331 1331 + tonic::Status, 1332 1332 + > { 1333 1333 + self.inner 1334 1334 + .ready() 1335 1335 + .await 1336 1336 + .map_err(|e| { 1337 1337 + tonic::Status::unknown( 1338 1338 + format!("Service was not ready: {}", e.into()), 1339 1339 + ) 1340 1340 + })?; 1220 1341 let codec = tonic::codec::ProstCodec::default(); 1221 1221 - let path = 1222 1222 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbum"); 1342 1342 + let path = http::uri::PathAndQuery::from_static( 1343 1343 + "/rockbox.v1alpha1.LibraryService/GetAlbum", 1344 1344 + ); 1223 1345 let mut req = request.into_request(); 1224 1224 - req.extensions_mut().insert(GrpcMethod::new( 1225 1225 - "rockbox.v1alpha1.LibraryService", 1226 1226 - "GetAlbum", 1227 1227 - )); 1346 1346 + req.extensions_mut() 1347 1347 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbum")); 1228 1348 self.inner.unary(req, path, codec).await 1229 1349 } 1230 1350 pub async fn get_artist( 1231 1351 &mut self, 1232 1352 request: impl tonic::IntoRequest<super::GetArtistRequest>, 1233 1233 - ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status> { 1234 1234 - self.inner.ready().await.map_err(|e| { 1235 1235 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1236 1236 - })?; 1353 1353 + ) -> std::result::Result< 1354 1354 + tonic::Response<super::GetArtistResponse>, 1355 1355 + tonic::Status, 1356 1356 + > { 1357 1357 + self.inner 1358 1358 + .ready() 1359 1359 + .await 1360 1360 + .map_err(|e| { 1361 1361 + tonic::Status::unknown( 1362 1362 + format!("Service was not ready: {}", e.into()), 1363 1363 + ) 1364 1364 + })?; 1237 1365 let codec = tonic::codec::ProstCodec::default(); 1238 1238 - let path = 1239 1239 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtist"); 1366 1366 + let path = http::uri::PathAndQuery::from_static( 1367 1367 + "/rockbox.v1alpha1.LibraryService/GetArtist", 1368 1368 + ); 1240 1369 let mut req = request.into_request(); 1241 1241 - req.extensions_mut().insert(GrpcMethod::new( 1242 1242 - "rockbox.v1alpha1.LibraryService", 1243 1243 - "GetArtist", 1244 1244 - )); 1370 1370 + req.extensions_mut() 1371 1371 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtist")); 1245 1372 self.inner.unary(req, path, codec).await 1246 1373 } 1247 1374 pub async fn get_track( 1248 1375 &mut self, 1249 1376 request: impl tonic::IntoRequest<super::GetTrackRequest>, 1250 1250 - ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status> { 1251 1251 - self.inner.ready().await.map_err(|e| { 1252 1252 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1253 1253 - })?; 1377 1377 + ) -> std::result::Result< 1378 1378 + tonic::Response<super::GetTrackResponse>, 1379 1379 + tonic::Status, 1380 1380 + > { 1381 1381 + self.inner 1382 1382 + .ready() 1383 1383 + .await 1384 1384 + .map_err(|e| { 1385 1385 + tonic::Status::unknown( 1386 1386 + format!("Service was not ready: {}", e.into()), 1387 1387 + ) 1388 1388 + })?; 1254 1389 let codec = tonic::codec::ProstCodec::default(); 1255 1255 - let path = 1256 1256 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTrack"); 1390 1390 + let path = http::uri::PathAndQuery::from_static( 1391 1391 + "/rockbox.v1alpha1.LibraryService/GetTrack", 1392 1392 + ); 1257 1393 let mut req = request.into_request(); 1258 1258 - req.extensions_mut().insert(GrpcMethod::new( 1259 1259 - "rockbox.v1alpha1.LibraryService", 1260 1260 - "GetTrack", 1261 1261 - )); 1394 1394 + req.extensions_mut() 1395 1395 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTrack")); 1262 1396 self.inner.unary(req, path, codec).await 1263 1397 } 1264 1398 pub async fn like_track( 1265 1399 &mut self, 1266 1400 request: impl tonic::IntoRequest<super::LikeTrackRequest>, 1267 1267 - ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status> { 1268 1268 - self.inner.ready().await.map_err(|e| { 1269 1269 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1270 1270 - })?; 1401 1401 + ) -> std::result::Result< 1402 1402 + tonic::Response<super::LikeTrackResponse>, 1403 1403 + tonic::Status, 1404 1404 + > { 1405 1405 + self.inner 1406 1406 + .ready() 1407 1407 + .await 1408 1408 + .map_err(|e| { 1409 1409 + tonic::Status::unknown( 1410 1410 + format!("Service was not ready: {}", e.into()), 1411 1411 + ) 1412 1412 + })?; 1271 1413 let codec = tonic::codec::ProstCodec::default(); 1272 1272 - let path = 1273 1273 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeTrack"); 1414 1414 + let path = http::uri::PathAndQuery::from_static( 1415 1415 + "/rockbox.v1alpha1.LibraryService/LikeTrack", 1416 1416 + ); 1274 1417 let mut req = request.into_request(); 1275 1275 - req.extensions_mut().insert(GrpcMethod::new( 1276 1276 - "rockbox.v1alpha1.LibraryService", 1277 1277 - "LikeTrack", 1278 1278 - )); 1418 1418 + req.extensions_mut() 1419 1419 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeTrack")); 1279 1420 self.inner.unary(req, path, codec).await 1280 1421 } 1281 1422 pub async fn unlike_track( 1282 1423 &mut self, 1283 1424 request: impl tonic::IntoRequest<super::UnlikeTrackRequest>, 1284 1284 - ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status> 1285 1285 - { 1286 1286 - self.inner.ready().await.map_err(|e| { 1287 1287 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1288 1288 - })?; 1425 1425 + ) -> std::result::Result< 1426 1426 + tonic::Response<super::UnlikeTrackResponse>, 1427 1427 + tonic::Status, 1428 1428 + > { 1429 1429 + self.inner 1430 1430 + .ready() 1431 1431 + .await 1432 1432 + .map_err(|e| { 1433 1433 + tonic::Status::unknown( 1434 1434 + format!("Service was not ready: {}", e.into()), 1435 1435 + ) 1436 1436 + })?; 1289 1437 let codec = tonic::codec::ProstCodec::default(); 1290 1438 let path = http::uri::PathAndQuery::from_static( 1291 1439 "/rockbox.v1alpha1.LibraryService/UnlikeTrack", 1292 1440 ); 1293 1441 let mut req = request.into_request(); 1294 1294 - req.extensions_mut().insert(GrpcMethod::new( 1295 1295 - "rockbox.v1alpha1.LibraryService", 1296 1296 - "UnlikeTrack", 1297 1297 - )); 1442 1442 + req.extensions_mut() 1443 1443 + .insert( 1444 1444 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeTrack"), 1445 1445 + ); 1298 1446 self.inner.unary(req, path, codec).await 1299 1447 } 1300 1448 pub async fn like_album( 1301 1449 &mut self, 1302 1450 request: impl tonic::IntoRequest<super::LikeAlbumRequest>, 1303 1303 - ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status> { 1304 1304 - self.inner.ready().await.map_err(|e| { 1305 1305 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1306 1306 - })?; 1451 1451 + ) -> std::result::Result< 1452 1452 + tonic::Response<super::LikeAlbumResponse>, 1453 1453 + tonic::Status, 1454 1454 + > { 1455 1455 + self.inner 1456 1456 + .ready() 1457 1457 + .await 1458 1458 + .map_err(|e| { 1459 1459 + tonic::Status::unknown( 1460 1460 + format!("Service was not ready: {}", e.into()), 1461 1461 + ) 1462 1462 + })?; 1307 1463 let codec = tonic::codec::ProstCodec::default(); 1308 1308 - let path = 1309 1309 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeAlbum"); 1464 1464 + let path = http::uri::PathAndQuery::from_static( 1465 1465 + "/rockbox.v1alpha1.LibraryService/LikeAlbum", 1466 1466 + ); 1310 1467 let mut req = request.into_request(); 1311 1311 - req.extensions_mut().insert(GrpcMethod::new( 1312 1312 - "rockbox.v1alpha1.LibraryService", 1313 1313 - "LikeAlbum", 1314 1314 - )); 1468 1468 + req.extensions_mut() 1469 1469 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeAlbum")); 1315 1470 self.inner.unary(req, path, codec).await 1316 1471 } 1317 1472 pub async fn unlike_album( 1318 1473 &mut self, 1319 1474 request: impl tonic::IntoRequest<super::UnlikeAlbumRequest>, 1320 1320 - ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status> 1321 1321 - { 1322 1322 - self.inner.ready().await.map_err(|e| { 1323 1323 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1324 1324 - })?; 1475 1475 + ) -> std::result::Result< 1476 1476 + tonic::Response<super::UnlikeAlbumResponse>, 1477 1477 + tonic::Status, 1478 1478 + > { 1479 1479 + self.inner 1480 1480 + .ready() 1481 1481 + .await 1482 1482 + .map_err(|e| { 1483 1483 + tonic::Status::unknown( 1484 1484 + format!("Service was not ready: {}", e.into()), 1485 1485 + ) 1486 1486 + })?; 1325 1487 let codec = tonic::codec::ProstCodec::default(); 1326 1488 let path = http::uri::PathAndQuery::from_static( 1327 1489 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum", 1328 1490 ); 1329 1491 let mut req = request.into_request(); 1330 1330 - req.extensions_mut().insert(GrpcMethod::new( 1331 1331 - "rockbox.v1alpha1.LibraryService", 1332 1332 - "UnlikeAlbum", 1333 1333 - )); 1492 1492 + req.extensions_mut() 1493 1493 + .insert( 1494 1494 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeAlbum"), 1495 1495 + ); 1334 1496 self.inner.unary(req, path, codec).await 1335 1497 } 1336 1498 pub async fn get_liked_tracks( 1337 1499 &mut self, 1338 1500 request: impl tonic::IntoRequest<super::GetLikedTracksRequest>, 1339 1339 - ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status> 1340 1340 - { 1341 1341 - self.inner.ready().await.map_err(|e| { 1342 1342 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1343 1343 - })?; 1501 1501 + ) -> std::result::Result< 1502 1502 + tonic::Response<super::GetLikedTracksResponse>, 1503 1503 + tonic::Status, 1504 1504 + > { 1505 1505 + self.inner 1506 1506 + .ready() 1507 1507 + .await 1508 1508 + .map_err(|e| { 1509 1509 + tonic::Status::unknown( 1510 1510 + format!("Service was not ready: {}", e.into()), 1511 1511 + ) 1512 1512 + })?; 1344 1513 let codec = tonic::codec::ProstCodec::default(); 1345 1514 let path = http::uri::PathAndQuery::from_static( 1346 1515 "/rockbox.v1alpha1.LibraryService/GetLikedTracks", 1347 1516 ); 1348 1517 let mut req = request.into_request(); 1349 1349 - req.extensions_mut().insert(GrpcMethod::new( 1350 1350 - "rockbox.v1alpha1.LibraryService", 1351 1351 - "GetLikedTracks", 1352 1352 - )); 1518 1518 + req.extensions_mut() 1519 1519 + .insert( 1520 1520 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedTracks"), 1521 1521 + ); 1353 1522 self.inner.unary(req, path, codec).await 1354 1523 } 1355 1524 pub async fn get_liked_albums( 1356 1525 &mut self, 1357 1526 request: impl tonic::IntoRequest<super::GetLikedAlbumsRequest>, 1358 1358 - ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status> 1359 1359 - { 1360 1360 - self.inner.ready().await.map_err(|e| { 1361 1361 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1362 1362 - })?; 1527 1527 + ) -> std::result::Result< 1528 1528 + tonic::Response<super::GetLikedAlbumsResponse>, 1529 1529 + tonic::Status, 1530 1530 + > { 1531 1531 + self.inner 1532 1532 + .ready() 1533 1533 + .await 1534 1534 + .map_err(|e| { 1535 1535 + tonic::Status::unknown( 1536 1536 + format!("Service was not ready: {}", e.into()), 1537 1537 + ) 1538 1538 + })?; 1363 1539 let codec = tonic::codec::ProstCodec::default(); 1364 1540 let path = http::uri::PathAndQuery::from_static( 1365 1541 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums", 1366 1542 ); 1367 1543 let mut req = request.into_request(); 1368 1368 - req.extensions_mut().insert(GrpcMethod::new( 1369 1369 - "rockbox.v1alpha1.LibraryService", 1370 1370 - "GetLikedAlbums", 1371 1371 - )); 1544 1544 + req.extensions_mut() 1545 1545 + .insert( 1546 1546 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedAlbums"), 1547 1547 + ); 1372 1548 self.inner.unary(req, path, codec).await 1373 1549 } 1374 1550 pub async fn scan_library( 1375 1551 &mut self, 1376 1552 request: impl tonic::IntoRequest<super::ScanLibraryRequest>, 1377 1377 - ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status> 1378 1378 - { 1379 1379 - self.inner.ready().await.map_err(|e| { 1380 1380 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1381 1381 - })?; 1553 1553 + ) -> std::result::Result< 1554 1554 + tonic::Response<super::ScanLibraryResponse>, 1555 1555 + tonic::Status, 1556 1556 + > { 1557 1557 + self.inner 1558 1558 + .ready() 1559 1559 + .await 1560 1560 + .map_err(|e| { 1561 1561 + tonic::Status::unknown( 1562 1562 + format!("Service was not ready: {}", e.into()), 1563 1563 + ) 1564 1564 + })?; 1382 1565 let codec = tonic::codec::ProstCodec::default(); 1383 1566 let path = http::uri::PathAndQuery::from_static( 1384 1567 "/rockbox.v1alpha1.LibraryService/ScanLibrary", 1385 1568 ); 1386 1569 let mut req = request.into_request(); 1387 1387 - req.extensions_mut().insert(GrpcMethod::new( 1388 1388 - "rockbox.v1alpha1.LibraryService", 1389 1389 - "ScanLibrary", 1390 1390 - )); 1570 1570 + req.extensions_mut() 1571 1571 + .insert( 1572 1572 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "ScanLibrary"), 1573 1573 + ); 1391 1574 self.inner.unary(req, path, codec).await 1392 1575 } 1393 1576 pub async fn stream_library( ··· 1397 1580 tonic::Response<tonic::codec::Streaming<super::StreamLibraryResponse>>, 1398 1581 tonic::Status, 1399 1582 > { 1400 1400 - self.inner.ready().await.map_err(|e| { 1401 1401 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1402 1402 - })?; 1583 1583 + self.inner 1584 1584 + .ready() 1585 1585 + .await 1586 1586 + .map_err(|e| { 1587 1587 + tonic::Status::unknown( 1588 1588 + format!("Service was not ready: {}", e.into()), 1589 1589 + ) 1590 1590 + })?; 1403 1591 let codec = tonic::codec::ProstCodec::default(); 1404 1592 let path = http::uri::PathAndQuery::from_static( 1405 1593 "/rockbox.v1alpha1.LibraryService/StreamLibrary", 1406 1594 ); 1407 1595 let mut req = request.into_request(); 1408 1408 - req.extensions_mut().insert(GrpcMethod::new( 1409 1409 - "rockbox.v1alpha1.LibraryService", 1410 1410 - "StreamLibrary", 1411 1411 - )); 1596 1596 + req.extensions_mut() 1597 1597 + .insert( 1598 1598 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "StreamLibrary"), 1599 1599 + ); 1412 1600 self.inner.server_streaming(req, path, codec).await 1413 1601 } 1414 1602 pub async fn search( 1415 1603 &mut self, 1416 1604 request: impl tonic::IntoRequest<super::SearchRequest>, 1417 1605 ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> { 1418 1418 - self.inner.ready().await.map_err(|e| { 1419 1419 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1420 1420 - })?; 1606 1606 + self.inner 1607 1607 + .ready() 1608 1608 + .await 1609 1609 + .map_err(|e| { 1610 1610 + tonic::Status::unknown( 1611 1611 + format!("Service was not ready: {}", e.into()), 1612 1612 + ) 1613 1613 + })?; 1421 1614 let codec = tonic::codec::ProstCodec::default(); 1422 1422 - let path = 1423 1423 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/Search"); 1615 1615 + let path = http::uri::PathAndQuery::from_static( 1616 1616 + "/rockbox.v1alpha1.LibraryService/Search", 1617 1617 + ); 1424 1618 let mut req = request.into_request(); 1425 1619 req.extensions_mut() 1426 1620 .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "Search")); ··· 1435 1629 dead_code, 1436 1630 missing_docs, 1437 1631 clippy::wildcard_imports, 1438 1438 - clippy::let_unit_value 1632 1632 + clippy::let_unit_value, 1439 1633 )] 1440 1634 use tonic::codegen::*; 1441 1635 /// Generated trait containing gRPC methods that should be implemented for use with LibraryServiceServer. ··· 1444 1638 async fn get_albums( 1445 1639 &self, 1446 1640 request: tonic::Request<super::GetAlbumsRequest>, 1447 1447 - ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status>; 1641 1641 + ) -> std::result::Result< 1642 1642 + tonic::Response<super::GetAlbumsResponse>, 1643 1643 + tonic::Status, 1644 1644 + >; 1448 1645 async fn get_artists( 1449 1646 &self, 1450 1647 request: tonic::Request<super::GetArtistsRequest>, 1451 1451 - ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status>; 1648 1648 + ) -> std::result::Result< 1649 1649 + tonic::Response<super::GetArtistsResponse>, 1650 1650 + tonic::Status, 1651 1651 + >; 1452 1652 async fn get_tracks( 1453 1653 &self, 1454 1654 request: tonic::Request<super::GetTracksRequest>, 1455 1455 - ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status>; 1655 1655 + ) -> std::result::Result< 1656 1656 + tonic::Response<super::GetTracksResponse>, 1657 1657 + tonic::Status, 1658 1658 + >; 1456 1659 async fn get_album( 1457 1660 &self, 1458 1661 request: tonic::Request<super::GetAlbumRequest>, 1459 1459 - ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status>; 1662 1662 + ) -> std::result::Result< 1663 1663 + tonic::Response<super::GetAlbumResponse>, 1664 1664 + tonic::Status, 1665 1665 + >; 1460 1666 async fn get_artist( 1461 1667 &self, 1462 1668 request: tonic::Request<super::GetArtistRequest>, 1463 1463 - ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status>; 1669 1669 + ) -> std::result::Result< 1670 1670 + tonic::Response<super::GetArtistResponse>, 1671 1671 + tonic::Status, 1672 1672 + >; 1464 1673 async fn get_track( 1465 1674 &self, 1466 1675 request: tonic::Request<super::GetTrackRequest>, 1467 1467 - ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status>; 1676 1676 + ) -> std::result::Result< 1677 1677 + tonic::Response<super::GetTrackResponse>, 1678 1678 + tonic::Status, 1679 1679 + >; 1468 1680 async fn like_track( 1469 1681 &self, 1470 1682 request: tonic::Request<super::LikeTrackRequest>, 1471 1471 - ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status>; 1683 1683 + ) -> std::result::Result< 1684 1684 + tonic::Response<super::LikeTrackResponse>, 1685 1685 + tonic::Status, 1686 1686 + >; 1472 1687 async fn unlike_track( 1473 1688 &self, 1474 1689 request: tonic::Request<super::UnlikeTrackRequest>, 1475 1475 - ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status>; 1690 1690 + ) -> std::result::Result< 1691 1691 + tonic::Response<super::UnlikeTrackResponse>, 1692 1692 + tonic::Status, 1693 1693 + >; 1476 1694 async fn like_album( 1477 1695 &self, 1478 1696 request: tonic::Request<super::LikeAlbumRequest>, 1479 1479 - ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status>; 1697 1697 + ) -> std::result::Result< 1698 1698 + tonic::Response<super::LikeAlbumResponse>, 1699 1699 + tonic::Status, 1700 1700 + >; 1480 1701 async fn unlike_album( 1481 1702 &self, 1482 1703 request: tonic::Request<super::UnlikeAlbumRequest>, 1483 1483 - ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status>; 1704 1704 + ) -> std::result::Result< 1705 1705 + tonic::Response<super::UnlikeAlbumResponse>, 1706 1706 + tonic::Status, 1707 1707 + >; 1484 1708 async fn get_liked_tracks( 1485 1709 &self, 1486 1710 request: tonic::Request<super::GetLikedTracksRequest>, 1487 1487 - ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status>; 1711 1711 + ) -> std::result::Result< 1712 1712 + tonic::Response<super::GetLikedTracksResponse>, 1713 1713 + tonic::Status, 1714 1714 + >; 1488 1715 async fn get_liked_albums( 1489 1716 &self, 1490 1717 request: tonic::Request<super::GetLikedAlbumsRequest>, 1491 1491 - ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status>; 1718 1718 + ) -> std::result::Result< 1719 1719 + tonic::Response<super::GetLikedAlbumsResponse>, 1720 1720 + tonic::Status, 1721 1721 + >; 1492 1722 async fn scan_library( 1493 1723 &self, 1494 1724 request: tonic::Request<super::ScanLibraryRequest>, 1495 1495 - ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>; 1725 1725 + ) -> std::result::Result< 1726 1726 + tonic::Response<super::ScanLibraryResponse>, 1727 1727 + tonic::Status, 1728 1728 + >; 1496 1729 /// Server streaming response type for the StreamLibrary method. 1497 1730 type StreamLibraryStream: tonic::codegen::tokio_stream::Stream< 1498 1731 Item = std::result::Result<super::StreamLibraryResponse, tonic::Status>, 1499 1499 - > + std::marker::Send 1732 1732 + > 1733 1733 + + std::marker::Send 1500 1734 + 'static; 1501 1735 async fn stream_library( 1502 1736 &self, 1503 1737 request: tonic::Request<super::StreamLibraryRequest>, 1504 1504 - ) -> std::result::Result<tonic::Response<Self::StreamLibraryStream>, tonic::Status>; 1738 1738 + ) -> std::result::Result< 1739 1739 + tonic::Response<Self::StreamLibraryStream>, 1740 1740 + tonic::Status, 1741 1741 + >; 1505 1742 async fn search( 1506 1743 &self, 1507 1744 request: tonic::Request<super::SearchRequest>, ··· 1528 1765 max_encoding_message_size: None, 1529 1766 } 1530 1767 } 1531 1531 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1768 1768 + pub fn with_interceptor<F>( 1769 1769 + inner: T, 1770 1770 + interceptor: F, 1771 1771 + ) -> InterceptedService<Self, F> 1532 1772 where 1533 1773 F: tonic::service::Interceptor, 1534 1774 { ··· 1583 1823 "/rockbox.v1alpha1.LibraryService/GetAlbums" => { 1584 1824 #[allow(non_camel_case_types)] 1585 1825 struct GetAlbumsSvc<T: LibraryService>(pub Arc<T>); 1586 1586 - impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumsRequest> for GetAlbumsSvc<T> { 1826 1826 + impl< 1827 1827 + T: LibraryService, 1828 1828 + > tonic::server::UnaryService<super::GetAlbumsRequest> 1829 1829 + for GetAlbumsSvc<T> { 1587 1830 type Response = super::GetAlbumsResponse; 1588 1588 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1831 1831 + type Future = BoxFuture< 1832 1832 + tonic::Response<Self::Response>, 1833 1833 + tonic::Status, 1834 1834 + >; 1589 1835 fn call( 1590 1836 &mut self, 1591 1837 request: tonic::Request<super::GetAlbumsRequest>, ··· 1622 1868 "/rockbox.v1alpha1.LibraryService/GetArtists" => { 1623 1869 #[allow(non_camel_case_types)] 1624 1870 struct GetArtistsSvc<T: LibraryService>(pub Arc<T>); 1625 1625 - impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistsRequest> for GetArtistsSvc<T> { 1871 1871 + impl< 1872 1872 + T: LibraryService, 1873 1873 + > tonic::server::UnaryService<super::GetArtistsRequest> 1874 1874 + for GetArtistsSvc<T> { 1626 1875 type Response = super::GetArtistsResponse; 1627 1627 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1876 1876 + type Future = BoxFuture< 1877 1877 + tonic::Response<Self::Response>, 1878 1878 + tonic::Status, 1879 1879 + >; 1628 1880 fn call( 1629 1881 &mut self, 1630 1882 request: tonic::Request<super::GetArtistsRequest>, ··· 1661 1913 "/rockbox.v1alpha1.LibraryService/GetTracks" => { 1662 1914 #[allow(non_camel_case_types)] 1663 1915 struct GetTracksSvc<T: LibraryService>(pub Arc<T>); 1664 1664 - impl<T: LibraryService> tonic::server::UnaryService<super::GetTracksRequest> for GetTracksSvc<T> { 1916 1916 + impl< 1917 1917 + T: LibraryService, 1918 1918 + > tonic::server::UnaryService<super::GetTracksRequest> 1919 1919 + for GetTracksSvc<T> { 1665 1920 type Response = super::GetTracksResponse; 1666 1666 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1921 1921 + type Future = BoxFuture< 1922 1922 + tonic::Response<Self::Response>, 1923 1923 + tonic::Status, 1924 1924 + >; 1667 1925 fn call( 1668 1926 &mut self, 1669 1927 request: tonic::Request<super::GetTracksRequest>, ··· 1700 1958 "/rockbox.v1alpha1.LibraryService/GetAlbum" => { 1701 1959 #[allow(non_camel_case_types)] 1702 1960 struct GetAlbumSvc<T: LibraryService>(pub Arc<T>); 1703 1703 - impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumRequest> for GetAlbumSvc<T> { 1961 1961 + impl< 1962 1962 + T: LibraryService, 1963 1963 + > tonic::server::UnaryService<super::GetAlbumRequest> 1964 1964 + for GetAlbumSvc<T> { 1704 1965 type Response = super::GetAlbumResponse; 1705 1705 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1966 1966 + type Future = BoxFuture< 1967 1967 + tonic::Response<Self::Response>, 1968 1968 + tonic::Status, 1969 1969 + >; 1706 1970 fn call( 1707 1971 &mut self, 1708 1972 request: tonic::Request<super::GetAlbumRequest>, ··· 1739 2003 "/rockbox.v1alpha1.LibraryService/GetArtist" => { 1740 2004 #[allow(non_camel_case_types)] 1741 2005 struct GetArtistSvc<T: LibraryService>(pub Arc<T>); 1742 1742 - impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistRequest> for GetArtistSvc<T> { 2006 2006 + impl< 2007 2007 + T: LibraryService, 2008 2008 + > tonic::server::UnaryService<super::GetArtistRequest> 2009 2009 + for GetArtistSvc<T> { 1743 2010 type Response = super::GetArtistResponse; 1744 1744 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2011 2011 + type Future = BoxFuture< 2012 2012 + tonic::Response<Self::Response>, 2013 2013 + tonic::Status, 2014 2014 + >; 1745 2015 fn call( 1746 2016 &mut self, 1747 2017 request: tonic::Request<super::GetArtistRequest>, ··· 1778 2048 "/rockbox.v1alpha1.LibraryService/GetTrack" => { 1779 2049 #[allow(non_camel_case_types)] 1780 2050 struct GetTrackSvc<T: LibraryService>(pub Arc<T>); 1781 1781 - impl<T: LibraryService> tonic::server::UnaryService<super::GetTrackRequest> for GetTrackSvc<T> { 2051 2051 + impl< 2052 2052 + T: LibraryService, 2053 2053 + > tonic::server::UnaryService<super::GetTrackRequest> 2054 2054 + for GetTrackSvc<T> { 1782 2055 type Response = super::GetTrackResponse; 1783 1783 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2056 2056 + type Future = BoxFuture< 2057 2057 + tonic::Response<Self::Response>, 2058 2058 + tonic::Status, 2059 2059 + >; 1784 2060 fn call( 1785 2061 &mut self, 1786 2062 request: tonic::Request<super::GetTrackRequest>, ··· 1817 2093 "/rockbox.v1alpha1.LibraryService/LikeTrack" => { 1818 2094 #[allow(non_camel_case_types)] 1819 2095 struct LikeTrackSvc<T: LibraryService>(pub Arc<T>); 1820 1820 - impl<T: LibraryService> tonic::server::UnaryService<super::LikeTrackRequest> for LikeTrackSvc<T> { 2096 2096 + impl< 2097 2097 + T: LibraryService, 2098 2098 + > tonic::server::UnaryService<super::LikeTrackRequest> 2099 2099 + for LikeTrackSvc<T> { 1821 2100 type Response = super::LikeTrackResponse; 1822 1822 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2101 2101 + type Future = BoxFuture< 2102 2102 + tonic::Response<Self::Response>, 2103 2103 + tonic::Status, 2104 2104 + >; 1823 2105 fn call( 1824 2106 &mut self, 1825 2107 request: tonic::Request<super::LikeTrackRequest>, ··· 1856 2138 "/rockbox.v1alpha1.LibraryService/UnlikeTrack" => { 1857 2139 #[allow(non_camel_case_types)] 1858 2140 struct UnlikeTrackSvc<T: LibraryService>(pub Arc<T>); 1859 1859 - impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeTrackRequest> 1860 1860 - for UnlikeTrackSvc<T> 1861 1861 - { 2141 2141 + impl< 2142 2142 + T: LibraryService, 2143 2143 + > tonic::server::UnaryService<super::UnlikeTrackRequest> 2144 2144 + for UnlikeTrackSvc<T> { 1862 2145 type Response = super::UnlikeTrackResponse; 1863 1863 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2146 2146 + type Future = BoxFuture< 2147 2147 + tonic::Response<Self::Response>, 2148 2148 + tonic::Status, 2149 2149 + >; 1864 2150 fn call( 1865 2151 &mut self, 1866 2152 request: tonic::Request<super::UnlikeTrackRequest>, ··· 1897 2183 "/rockbox.v1alpha1.LibraryService/LikeAlbum" => { 1898 2184 #[allow(non_camel_case_types)] 1899 2185 struct LikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1900 1900 - impl<T: LibraryService> tonic::server::UnaryService<super::LikeAlbumRequest> for LikeAlbumSvc<T> { 2186 2186 + impl< 2187 2187 + T: LibraryService, 2188 2188 + > tonic::server::UnaryService<super::LikeAlbumRequest> 2189 2189 + for LikeAlbumSvc<T> { 1901 2190 type Response = super::LikeAlbumResponse; 1902 1902 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2191 2191 + type Future = BoxFuture< 2192 2192 + tonic::Response<Self::Response>, 2193 2193 + tonic::Status, 2194 2194 + >; 1903 2195 fn call( 1904 2196 &mut self, 1905 2197 request: tonic::Request<super::LikeAlbumRequest>, ··· 1936 2228 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum" => { 1937 2229 #[allow(non_camel_case_types)] 1938 2230 struct UnlikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1939 1939 - impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeAlbumRequest> 1940 1940 - for UnlikeAlbumSvc<T> 1941 1941 - { 2231 2231 + impl< 2232 2232 + T: LibraryService, 2233 2233 + > tonic::server::UnaryService<super::UnlikeAlbumRequest> 2234 2234 + for UnlikeAlbumSvc<T> { 1942 2235 type Response = super::UnlikeAlbumResponse; 1943 1943 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2236 2236 + type Future = BoxFuture< 2237 2237 + tonic::Response<Self::Response>, 2238 2238 + tonic::Status, 2239 2239 + >; 1944 2240 fn call( 1945 2241 &mut self, 1946 2242 request: tonic::Request<super::UnlikeAlbumRequest>, ··· 1977 2273 "/rockbox.v1alpha1.LibraryService/GetLikedTracks" => { 1978 2274 #[allow(non_camel_case_types)] 1979 2275 struct GetLikedTracksSvc<T: LibraryService>(pub Arc<T>); 1980 1980 - impl<T: LibraryService> 1981 1981 - tonic::server::UnaryService<super::GetLikedTracksRequest> 1982 1982 - for GetLikedTracksSvc<T> 1983 1983 - { 2276 2276 + impl< 2277 2277 + T: LibraryService, 2278 2278 + > tonic::server::UnaryService<super::GetLikedTracksRequest> 2279 2279 + for GetLikedTracksSvc<T> { 1984 2280 type Response = super::GetLikedTracksResponse; 1985 1985 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2281 2281 + type Future = BoxFuture< 2282 2282 + tonic::Response<Self::Response>, 2283 2283 + tonic::Status, 2284 2284 + >; 1986 2285 fn call( 1987 2286 &mut self, 1988 2287 request: tonic::Request<super::GetLikedTracksRequest>, 1989 2288 ) -> Self::Future { 1990 2289 let inner = Arc::clone(&self.0); 1991 2290 let fut = async move { 1992 1992 - <T as LibraryService>::get_liked_tracks(&inner, request).await 2291 2291 + <T as LibraryService>::get_liked_tracks(&inner, request) 2292 2292 + .await 1993 2293 }; 1994 2294 Box::pin(fut) 1995 2295 } ··· 2019 2319 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums" => { 2020 2320 #[allow(non_camel_case_types)] 2021 2321 struct GetLikedAlbumsSvc<T: LibraryService>(pub Arc<T>); 2022 2022 - impl<T: LibraryService> 2023 2023 - tonic::server::UnaryService<super::GetLikedAlbumsRequest> 2024 2024 - for GetLikedAlbumsSvc<T> 2025 2025 - { 2322 2322 + impl< 2323 2323 + T: LibraryService, 2324 2324 + > tonic::server::UnaryService<super::GetLikedAlbumsRequest> 2325 2325 + for GetLikedAlbumsSvc<T> { 2026 2326 type Response = super::GetLikedAlbumsResponse; 2027 2027 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2327 2327 + type Future = BoxFuture< 2328 2328 + tonic::Response<Self::Response>, 2329 2329 + tonic::Status, 2330 2330 + >; 2028 2331 fn call( 2029 2332 &mut self, 2030 2333 request: tonic::Request<super::GetLikedAlbumsRequest>, 2031 2334 ) -> Self::Future { 2032 2335 let inner = Arc::clone(&self.0); 2033 2336 let fut = async move { 2034 2034 - <T as LibraryService>::get_liked_albums(&inner, request).await 2337 2337 + <T as LibraryService>::get_liked_albums(&inner, request) 2338 2338 + .await 2035 2339 }; 2036 2340 Box::pin(fut) 2037 2341 } ··· 2061 2365 "/rockbox.v1alpha1.LibraryService/ScanLibrary" => { 2062 2366 #[allow(non_camel_case_types)] 2063 2367 struct ScanLibrarySvc<T: LibraryService>(pub Arc<T>); 2064 2064 - impl<T: LibraryService> tonic::server::UnaryService<super::ScanLibraryRequest> 2065 2065 - for ScanLibrarySvc<T> 2066 2066 - { 2368 2368 + impl< 2369 2369 + T: LibraryService, 2370 2370 + > tonic::server::UnaryService<super::ScanLibraryRequest> 2371 2371 + for ScanLibrarySvc<T> { 2067 2372 type Response = super::ScanLibraryResponse; 2068 2068 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2373 2373 + type Future = BoxFuture< 2374 2374 + tonic::Response<Self::Response>, 2375 2375 + tonic::Status, 2376 2376 + >; 2069 2377 fn call( 2070 2378 &mut self, 2071 2379 request: tonic::Request<super::ScanLibraryRequest>, ··· 2102 2410 "/rockbox.v1alpha1.LibraryService/StreamLibrary" => { 2103 2411 #[allow(non_camel_case_types)] 2104 2412 struct StreamLibrarySvc<T: LibraryService>(pub Arc<T>); 2105 2105 - impl<T: LibraryService> 2106 2106 - tonic::server::ServerStreamingService<super::StreamLibraryRequest> 2107 2107 - for StreamLibrarySvc<T> 2108 2108 - { 2413 2413 + impl< 2414 2414 + T: LibraryService, 2415 2415 + > tonic::server::ServerStreamingService<super::StreamLibraryRequest> 2416 2416 + for StreamLibrarySvc<T> { 2109 2417 type Response = super::StreamLibraryResponse; 2110 2418 type ResponseStream = T::StreamLibraryStream; 2111 2111 - type Future = 2112 2112 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 2419 2419 + type Future = BoxFuture< 2420 2420 + tonic::Response<Self::ResponseStream>, 2421 2421 + tonic::Status, 2422 2422 + >; 2113 2423 fn call( 2114 2424 &mut self, 2115 2425 request: tonic::Request<super::StreamLibraryRequest>, ··· 2146 2456 "/rockbox.v1alpha1.LibraryService/Search" => { 2147 2457 #[allow(non_camel_case_types)] 2148 2458 struct SearchSvc<T: LibraryService>(pub Arc<T>); 2149 2149 - impl<T: LibraryService> tonic::server::UnaryService<super::SearchRequest> for SearchSvc<T> { 2459 2459 + impl< 2460 2460 + T: LibraryService, 2461 2461 + > tonic::server::UnaryService<super::SearchRequest> 2462 2462 + for SearchSvc<T> { 2150 2463 type Response = super::SearchResponse; 2151 2151 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2464 2464 + type Future = BoxFuture< 2465 2465 + tonic::Response<Self::Response>, 2466 2466 + tonic::Status, 2467 2467 + >; 2152 2468 fn call( 2153 2469 &mut self, 2154 2470 request: tonic::Request<super::SearchRequest>, 2155 2471 ) -> Self::Future { 2156 2472 let inner = Arc::clone(&self.0); 2157 2157 - let fut = 2158 2158 - async move { <T as LibraryService>::search(&inner, request).await }; 2473 2473 + let fut = async move { 2474 2474 + <T as LibraryService>::search(&inner, request).await 2475 2475 + }; 2159 2476 Box::pin(fut) 2160 2477 } 2161 2478 } ··· 2181 2498 }; 2182 2499 Box::pin(fut) 2183 2500 } 2184 2184 - _ => Box::pin(async move { 2185 2185 - let mut response = http::Response::new(empty_body()); 2186 2186 - let headers = response.headers_mut(); 2187 2187 - headers.insert( 2188 2188 - tonic::Status::GRPC_STATUS, 2189 2189 - (tonic::Code::Unimplemented as i32).into(), 2190 2190 - ); 2191 2191 - headers.insert( 2192 2192 - http::header::CONTENT_TYPE, 2193 2193 - tonic::metadata::GRPC_CONTENT_TYPE, 2194 2194 - ); 2195 2195 - Ok(response) 2196 2196 - }), 2501 2501 + _ => { 2502 2502 + Box::pin(async move { 2503 2503 + let mut response = http::Response::new(empty_body()); 2504 2504 + let headers = response.headers_mut(); 2505 2505 + headers 2506 2506 + .insert( 2507 2507 + tonic::Status::GRPC_STATUS, 2508 2508 + (tonic::Code::Unimplemented as i32).into(), 2509 2509 + ); 2510 2510 + headers 2511 2511 + .insert( 2512 2512 + http::header::CONTENT_TYPE, 2513 2513 + tonic::metadata::GRPC_CONTENT_TYPE, 2514 2514 + ); 2515 2515 + Ok(response) 2516 2516 + }) 2517 2517 + } 2197 2518 } 2198 2519 } 2199 2520 } ··· 2222 2543 dead_code, 2223 2544 missing_docs, 2224 2545 clippy::wildcard_imports, 2225 2225 - clippy::let_unit_value 2546 2546 + clippy::let_unit_value, 2226 2547 )] 2227 2227 - use tonic::codegen::http::Uri; 2228 2548 use tonic::codegen::*; 2549 2549 + use tonic::codegen::http::Uri; 2229 2550 #[derive(Debug, Clone)] 2230 2551 pub struct MetadataServiceClient<T> { 2231 2552 inner: tonic::client::Grpc<T>, ··· 2269 2590 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 2270 2591 >, 2271 2592 >, 2272 2272 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 2273 2273 - Into<StdError> + std::marker::Send + std::marker::Sync, 2593 2593 + <T as tonic::codegen::Service< 2594 2594 + http::Request<tonic::body::BoxBody>, 2595 2595 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 2274 2596 { 2275 2597 MetadataServiceClient::new(InterceptedService::new(inner, interceptor)) 2276 2598 } ··· 2314 2636 dead_code, 2315 2637 missing_docs, 2316 2638 clippy::wildcard_imports, 2317 2317 - clippy::let_unit_value 2639 2639 + clippy::let_unit_value, 2318 2640 )] 2319 2641 use tonic::codegen::*; 2320 2642 /// Generated trait containing gRPC methods that should be implemented for use with MetadataServiceServer. ··· 2341 2663 max_encoding_message_size: None, 2342 2664 } 2343 2665 } 2344 2344 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 2666 2666 + pub fn with_interceptor<F>( 2667 2667 + inner: T, 2668 2668 + interceptor: F, 2669 2669 + ) -> InterceptedService<Self, F> 2345 2670 where 2346 2671 F: tonic::service::Interceptor, 2347 2672 { ··· 2393 2718 } 2394 2719 fn call(&mut self, req: http::Request<B>) -> Self::Future { 2395 2720 match req.uri().path() { 2396 2396 - _ => Box::pin(async move { 2397 2397 - let mut response = http::Response::new(empty_body()); 2398 2398 - let headers = response.headers_mut(); 2399 2399 - headers.insert( 2400 2400 - tonic::Status::GRPC_STATUS, 2401 2401 - (tonic::Code::Unimplemented as i32).into(), 2402 2402 - ); 2403 2403 - headers.insert( 2404 2404 - http::header::CONTENT_TYPE, 2405 2405 - tonic::metadata::GRPC_CONTENT_TYPE, 2406 2406 - ); 2407 2407 - Ok(response) 2408 2408 - }), 2721 2721 + _ => { 2722 2722 + Box::pin(async move { 2723 2723 + let mut response = http::Response::new(empty_body()); 2724 2724 + let headers = response.headers_mut(); 2725 2725 + headers 2726 2726 + .insert( 2727 2727 + tonic::Status::GRPC_STATUS, 2728 2728 + (tonic::Code::Unimplemented as i32).into(), 2729 2729 + ); 2730 2730 + headers 2731 2731 + .insert( 2732 2732 + http::header::CONTENT_TYPE, 2733 2733 + tonic::metadata::GRPC_CONTENT_TYPE, 2734 2734 + ); 2735 2735 + Ok(response) 2736 2736 + }) 2737 2737 + } 2409 2738 } 2410 2739 } 2411 2740 } ··· 2689 3018 dead_code, 2690 3019 missing_docs, 2691 3020 clippy::wildcard_imports, 2692 2692 - clippy::let_unit_value 3021 3021 + clippy::let_unit_value, 2693 3022 )] 2694 2694 - use tonic::codegen::http::Uri; 2695 3023 use tonic::codegen::*; 3024 3024 + use tonic::codegen::http::Uri; 2696 3025 #[derive(Debug, Clone)] 2697 3026 pub struct PlaybackServiceClient<T> { 2698 3027 inner: tonic::client::Grpc<T>, ··· 2736 3065 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 2737 3066 >, 2738 3067 >, 2739 2739 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 2740 2740 - Into<StdError> + std::marker::Send + std::marker::Sync, 3068 3068 + <T as tonic::codegen::Service< 3069 3069 + http::Request<tonic::body::BoxBody>, 3070 3070 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 2741 3071 { 2742 3072 PlaybackServiceClient::new(InterceptedService::new(inner, interceptor)) 2743 3073 } ··· 2776 3106 &mut self, 2777 3107 request: impl tonic::IntoRequest<super::PlayRequest>, 2778 3108 ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> { 2779 2779 - self.inner.ready().await.map_err(|e| { 2780 2780 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2781 2781 - })?; 3109 3109 + self.inner 3110 3110 + .ready() 3111 3111 + .await 3112 3112 + .map_err(|e| { 3113 3113 + tonic::Status::unknown( 3114 3114 + format!("Service was not ready: {}", e.into()), 3115 3115 + ) 3116 3116 + })?; 2782 3117 let codec = tonic::codec::ProstCodec::default(); 2783 2783 - let path = 2784 2784 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Play"); 3118 3118 + let path = http::uri::PathAndQuery::from_static( 3119 3119 + "/rockbox.v1alpha1.PlaybackService/Play", 3120 3120 + ); 2785 3121 let mut req = request.into_request(); 2786 3122 req.extensions_mut() 2787 3123 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Play")); ··· 2791 3127 &mut self, 2792 3128 request: impl tonic::IntoRequest<super::PauseRequest>, 2793 3129 ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> { 2794 2794 - self.inner.ready().await.map_err(|e| { 2795 2795 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2796 2796 - })?; 3130 3130 + self.inner 3131 3131 + .ready() 3132 3132 + .await 3133 3133 + .map_err(|e| { 3134 3134 + tonic::Status::unknown( 3135 3135 + format!("Service was not ready: {}", e.into()), 3136 3136 + ) 3137 3137 + })?; 2797 3138 let codec = tonic::codec::ProstCodec::default(); 2798 2798 - let path = 2799 2799 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Pause"); 3139 3139 + let path = http::uri::PathAndQuery::from_static( 3140 3140 + "/rockbox.v1alpha1.PlaybackService/Pause", 3141 3141 + ); 2800 3142 let mut req = request.into_request(); 2801 3143 req.extensions_mut() 2802 3144 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Pause")); ··· 2805 3147 pub async fn play_or_pause( 2806 3148 &mut self, 2807 3149 request: impl tonic::IntoRequest<super::PlayOrPauseRequest>, 2808 2808 - ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status> 2809 2809 - { 2810 2810 - self.inner.ready().await.map_err(|e| { 2811 2811 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2812 2812 - })?; 3150 3150 + ) -> std::result::Result< 3151 3151 + tonic::Response<super::PlayOrPauseResponse>, 3152 3152 + tonic::Status, 3153 3153 + > { 3154 3154 + self.inner 3155 3155 + .ready() 3156 3156 + .await 3157 3157 + .map_err(|e| { 3158 3158 + tonic::Status::unknown( 3159 3159 + format!("Service was not ready: {}", e.into()), 3160 3160 + ) 3161 3161 + })?; 2813 3162 let codec = tonic::codec::ProstCodec::default(); 2814 3163 let path = http::uri::PathAndQuery::from_static( 2815 3164 "/rockbox.v1alpha1.PlaybackService/PlayOrPause", 2816 3165 ); 2817 3166 let mut req = request.into_request(); 2818 2818 - req.extensions_mut().insert(GrpcMethod::new( 2819 2819 - "rockbox.v1alpha1.PlaybackService", 2820 2820 - "PlayOrPause", 2821 2821 - )); 3167 3167 + req.extensions_mut() 3168 3168 + .insert( 3169 3169 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayOrPause"), 3170 3170 + ); 2822 3171 self.inner.unary(req, path, codec).await 2823 3172 } 2824 3173 pub async fn resume( 2825 3174 &mut self, 2826 3175 request: impl tonic::IntoRequest<super::ResumeRequest>, 2827 3176 ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> { 2828 2828 - self.inner.ready().await.map_err(|e| { 2829 2829 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2830 2830 - })?; 3177 3177 + self.inner 3178 3178 + .ready() 3179 3179 + .await 3180 3180 + .map_err(|e| { 3181 3181 + tonic::Status::unknown( 3182 3182 + format!("Service was not ready: {}", e.into()), 3183 3183 + ) 3184 3184 + })?; 2831 3185 let codec = tonic::codec::ProstCodec::default(); 2832 2832 - let path = 2833 2833 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Resume"); 3186 3186 + let path = http::uri::PathAndQuery::from_static( 3187 3187 + "/rockbox.v1alpha1.PlaybackService/Resume", 3188 3188 + ); 2834 3189 let mut req = request.into_request(); 2835 2835 - req.extensions_mut().insert(GrpcMethod::new( 2836 2836 - "rockbox.v1alpha1.PlaybackService", 2837 2837 - "Resume", 2838 2838 - )); 3190 3190 + req.extensions_mut() 3191 3191 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Resume")); 2839 3192 self.inner.unary(req, path, codec).await 2840 3193 } 2841 3194 pub async fn next( 2842 3195 &mut self, 2843 3196 request: impl tonic::IntoRequest<super::NextRequest>, 2844 3197 ) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status> { 2845 2845 - self.inner.ready().await.map_err(|e| { 2846 2846 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2847 2847 - })?; 3198 3198 + self.inner 3199 3199 + .ready() 3200 3200 + .await 3201 3201 + .map_err(|e| { 3202 3202 + tonic::Status::unknown( 3203 3203 + format!("Service was not ready: {}", e.into()), 3204 3204 + ) 3205 3205 + })?; 2848 3206 let codec = tonic::codec::ProstCodec::default(); 2849 2849 - let path = 2850 2850 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Next"); 3207 3207 + let path = http::uri::PathAndQuery::from_static( 3208 3208 + "/rockbox.v1alpha1.PlaybackService/Next", 3209 3209 + ); 2851 3210 let mut req = request.into_request(); 2852 3211 req.extensions_mut() 2853 3212 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Next")); ··· 2856 3215 pub async fn previous( 2857 3216 &mut self, 2858 3217 request: impl tonic::IntoRequest<super::PreviousRequest>, 2859 2859 - ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status> { 2860 2860 - self.inner.ready().await.map_err(|e| { 2861 2861 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2862 2862 - })?; 3218 3218 + ) -> std::result::Result< 3219 3219 + tonic::Response<super::PreviousResponse>, 3220 3220 + tonic::Status, 3221 3221 + > { 3222 3222 + self.inner 3223 3223 + .ready() 3224 3224 + .await 3225 3225 + .map_err(|e| { 3226 3226 + tonic::Status::unknown( 3227 3227 + format!("Service was not ready: {}", e.into()), 3228 3228 + ) 3229 3229 + })?; 2863 3230 let codec = tonic::codec::ProstCodec::default(); 2864 2864 - let path = 2865 2865 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Previous"); 3231 3231 + let path = http::uri::PathAndQuery::from_static( 3232 3232 + "/rockbox.v1alpha1.PlaybackService/Previous", 3233 3233 + ); 2866 3234 let mut req = request.into_request(); 2867 2867 - req.extensions_mut().insert(GrpcMethod::new( 2868 2868 - "rockbox.v1alpha1.PlaybackService", 2869 2869 - "Previous", 2870 2870 - )); 3235 3235 + req.extensions_mut() 3236 3236 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Previous")); 2871 3237 self.inner.unary(req, path, codec).await 2872 3238 } 2873 3239 pub async fn fast_forward_rewind( 2874 3240 &mut self, 2875 3241 request: impl tonic::IntoRequest<super::FastForwardRewindRequest>, 2876 2876 - ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status> 2877 2877 - { 2878 2878 - self.inner.ready().await.map_err(|e| { 2879 2879 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2880 2880 - })?; 3242 3242 + ) -> std::result::Result< 3243 3243 + tonic::Response<super::FastForwardRewindResponse>, 3244 3244 + tonic::Status, 3245 3245 + > { 3246 3246 + self.inner 3247 3247 + .ready() 3248 3248 + .await 3249 3249 + .map_err(|e| { 3250 3250 + tonic::Status::unknown( 3251 3251 + format!("Service was not ready: {}", e.into()), 3252 3252 + ) 3253 3253 + })?; 2881 3254 let codec = tonic::codec::ProstCodec::default(); 2882 3255 let path = http::uri::PathAndQuery::from_static( 2883 3256 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind", 2884 3257 ); 2885 3258 let mut req = request.into_request(); 2886 2886 - req.extensions_mut().insert(GrpcMethod::new( 2887 2887 - "rockbox.v1alpha1.PlaybackService", 2888 2888 - "FastForwardRewind", 2889 2889 - )); 3259 3259 + req.extensions_mut() 3260 3260 + .insert( 3261 3261 + GrpcMethod::new( 3262 3262 + "rockbox.v1alpha1.PlaybackService", 3263 3263 + "FastForwardRewind", 3264 3264 + ), 3265 3265 + ); 2890 3266 self.inner.unary(req, path, codec).await 2891 3267 } 2892 3268 pub async fn status( 2893 3269 &mut self, 2894 3270 request: impl tonic::IntoRequest<super::StatusRequest>, 2895 3271 ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> { 2896 2896 - self.inner.ready().await.map_err(|e| { 2897 2897 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2898 2898 - })?; 3272 3272 + self.inner 3273 3273 + .ready() 3274 3274 + .await 3275 3275 + .map_err(|e| { 3276 3276 + tonic::Status::unknown( 3277 3277 + format!("Service was not ready: {}", e.into()), 3278 3278 + ) 3279 3279 + })?; 2899 3280 let codec = tonic::codec::ProstCodec::default(); 2900 2900 - let path = 2901 2901 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Status"); 3281 3281 + let path = http::uri::PathAndQuery::from_static( 3282 3282 + "/rockbox.v1alpha1.PlaybackService/Status", 3283 3283 + ); 2902 3284 let mut req = request.into_request(); 2903 2903 - req.extensions_mut().insert(GrpcMethod::new( 2904 2904 - "rockbox.v1alpha1.PlaybackService", 2905 2905 - "Status", 2906 2906 - )); 3285 3285 + req.extensions_mut() 3286 3286 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Status")); 2907 3287 self.inner.unary(req, path, codec).await 2908 3288 } 2909 3289 pub async fn current_track( 2910 3290 &mut self, 2911 3291 request: impl tonic::IntoRequest<super::CurrentTrackRequest>, 2912 2912 - ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status> 2913 2913 - { 2914 2914 - self.inner.ready().await.map_err(|e| { 2915 2915 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2916 2916 - })?; 3292 3292 + ) -> std::result::Result< 3293 3293 + tonic::Response<super::CurrentTrackResponse>, 3294 3294 + tonic::Status, 3295 3295 + > { 3296 3296 + self.inner 3297 3297 + .ready() 3298 3298 + .await 3299 3299 + .map_err(|e| { 3300 3300 + tonic::Status::unknown( 3301 3301 + format!("Service was not ready: {}", e.into()), 3302 3302 + ) 3303 3303 + })?; 2917 3304 let codec = tonic::codec::ProstCodec::default(); 2918 3305 let path = http::uri::PathAndQuery::from_static( 2919 3306 "/rockbox.v1alpha1.PlaybackService/CurrentTrack", 2920 3307 ); 2921 3308 let mut req = request.into_request(); 2922 2922 - req.extensions_mut().insert(GrpcMethod::new( 2923 2923 - "rockbox.v1alpha1.PlaybackService", 2924 2924 - "CurrentTrack", 2925 2925 - )); 3309 3309 + req.extensions_mut() 3310 3310 + .insert( 3311 3311 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "CurrentTrack"), 3312 3312 + ); 2926 3313 self.inner.unary(req, path, codec).await 2927 3314 } 2928 3315 pub async fn next_track( 2929 3316 &mut self, 2930 3317 request: impl tonic::IntoRequest<super::NextTrackRequest>, 2931 2931 - ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status> { 2932 2932 - self.inner.ready().await.map_err(|e| { 2933 2933 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2934 2934 - })?; 3318 3318 + ) -> std::result::Result< 3319 3319 + tonic::Response<super::NextTrackResponse>, 3320 3320 + tonic::Status, 3321 3321 + > { 3322 3322 + self.inner 3323 3323 + .ready() 3324 3324 + .await 3325 3325 + .map_err(|e| { 3326 3326 + tonic::Status::unknown( 3327 3327 + format!("Service was not ready: {}", e.into()), 3328 3328 + ) 3329 3329 + })?; 2935 3330 let codec = tonic::codec::ProstCodec::default(); 2936 2936 - let path = 2937 2937 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/NextTrack"); 3331 3331 + let path = http::uri::PathAndQuery::from_static( 3332 3332 + "/rockbox.v1alpha1.PlaybackService/NextTrack", 3333 3333 + ); 2938 3334 let mut req = request.into_request(); 2939 2939 - req.extensions_mut().insert(GrpcMethod::new( 2940 2940 - "rockbox.v1alpha1.PlaybackService", 2941 2941 - "NextTrack", 2942 2942 - )); 3335 3335 + req.extensions_mut() 3336 3336 + .insert( 3337 3337 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "NextTrack"), 3338 3338 + ); 2943 3339 self.inner.unary(req, path, codec).await 2944 3340 } 2945 3341 pub async fn flush_and_reload_tracks( 2946 3342 &mut self, 2947 3343 request: impl tonic::IntoRequest<super::FlushAndReloadTracksRequest>, 2948 2948 - ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status> 2949 2949 - { 2950 2950 - self.inner.ready().await.map_err(|e| { 2951 2951 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2952 2952 - })?; 3344 3344 + ) -> std::result::Result< 3345 3345 + tonic::Response<super::FlushAndReloadTracksResponse>, 3346 3346 + tonic::Status, 3347 3347 + > { 3348 3348 + self.inner 3349 3349 + .ready() 3350 3350 + .await 3351 3351 + .map_err(|e| { 3352 3352 + tonic::Status::unknown( 3353 3353 + format!("Service was not ready: {}", e.into()), 3354 3354 + ) 3355 3355 + })?; 2953 3356 let codec = tonic::codec::ProstCodec::default(); 2954 3357 let path = http::uri::PathAndQuery::from_static( 2955 3358 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks", 2956 3359 ); 2957 3360 let mut req = request.into_request(); 2958 2958 - req.extensions_mut().insert(GrpcMethod::new( 2959 2959 - "rockbox.v1alpha1.PlaybackService", 2960 2960 - "FlushAndReloadTracks", 2961 2961 - )); 3361 3361 + req.extensions_mut() 3362 3362 + .insert( 3363 3363 + GrpcMethod::new( 3364 3364 + "rockbox.v1alpha1.PlaybackService", 3365 3365 + "FlushAndReloadTracks", 3366 3366 + ), 3367 3367 + ); 2962 3368 self.inner.unary(req, path, codec).await 2963 3369 } 2964 3370 pub async fn get_file_position( 2965 3371 &mut self, 2966 3372 request: impl tonic::IntoRequest<super::GetFilePositionRequest>, 2967 2967 - ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status> 2968 2968 - { 2969 2969 - self.inner.ready().await.map_err(|e| { 2970 2970 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2971 2971 - })?; 3373 3373 + ) -> std::result::Result< 3374 3374 + tonic::Response<super::GetFilePositionResponse>, 3375 3375 + tonic::Status, 3376 3376 + > { 3377 3377 + self.inner 3378 3378 + .ready() 3379 3379 + .await 3380 3380 + .map_err(|e| { 3381 3381 + tonic::Status::unknown( 3382 3382 + format!("Service was not ready: {}", e.into()), 3383 3383 + ) 3384 3384 + })?; 2972 3385 let codec = tonic::codec::ProstCodec::default(); 2973 3386 let path = http::uri::PathAndQuery::from_static( 2974 3387 "/rockbox.v1alpha1.PlaybackService/GetFilePosition", 2975 3388 ); 2976 3389 let mut req = request.into_request(); 2977 2977 - req.extensions_mut().insert(GrpcMethod::new( 2978 2978 - "rockbox.v1alpha1.PlaybackService", 2979 2979 - "GetFilePosition", 2980 2980 - )); 3390 3390 + req.extensions_mut() 3391 3391 + .insert( 3392 3392 + GrpcMethod::new( 3393 3393 + "rockbox.v1alpha1.PlaybackService", 3394 3394 + "GetFilePosition", 3395 3395 + ), 3396 3396 + ); 2981 3397 self.inner.unary(req, path, codec).await 2982 3398 } 2983 3399 pub async fn hard_stop( 2984 3400 &mut self, 2985 3401 request: impl tonic::IntoRequest<super::HardStopRequest>, 2986 2986 - ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status> { 2987 2987 - self.inner.ready().await.map_err(|e| { 2988 2988 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2989 2989 - })?; 3402 3402 + ) -> std::result::Result< 3403 3403 + tonic::Response<super::HardStopResponse>, 3404 3404 + tonic::Status, 3405 3405 + > { 3406 3406 + self.inner 3407 3407 + .ready() 3408 3408 + .await 3409 3409 + .map_err(|e| { 3410 3410 + tonic::Status::unknown( 3411 3411 + format!("Service was not ready: {}", e.into()), 3412 3412 + ) 3413 3413 + })?; 2990 3414 let codec = tonic::codec::ProstCodec::default(); 2991 2991 - let path = 2992 2992 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/HardStop"); 3415 3415 + let path = http::uri::PathAndQuery::from_static( 3416 3416 + "/rockbox.v1alpha1.PlaybackService/HardStop", 3417 3417 + ); 2993 3418 let mut req = request.into_request(); 2994 2994 - req.extensions_mut().insert(GrpcMethod::new( 2995 2995 - "rockbox.v1alpha1.PlaybackService", 2996 2996 - "HardStop", 2997 2997 - )); 3419 3419 + req.extensions_mut() 3420 3420 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "HardStop")); 2998 3421 self.inner.unary(req, path, codec).await 2999 3422 } 3000 3423 pub async fn play_album( 3001 3424 &mut self, 3002 3425 request: impl tonic::IntoRequest<super::PlayAlbumRequest>, 3003 3003 - ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status> { 3004 3004 - self.inner.ready().await.map_err(|e| { 3005 3005 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3006 3006 - })?; 3426 3426 + ) -> std::result::Result< 3427 3427 + tonic::Response<super::PlayAlbumResponse>, 3428 3428 + tonic::Status, 3429 3429 + > { 3430 3430 + self.inner 3431 3431 + .ready() 3432 3432 + .await 3433 3433 + .map_err(|e| { 3434 3434 + tonic::Status::unknown( 3435 3435 + format!("Service was not ready: {}", e.into()), 3436 3436 + ) 3437 3437 + })?; 3007 3438 let codec = tonic::codec::ProstCodec::default(); 3008 3008 - let path = 3009 3009 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayAlbum"); 3439 3439 + let path = http::uri::PathAndQuery::from_static( 3440 3440 + "/rockbox.v1alpha1.PlaybackService/PlayAlbum", 3441 3441 + ); 3010 3442 let mut req = request.into_request(); 3011 3011 - req.extensions_mut().insert(GrpcMethod::new( 3012 3012 - "rockbox.v1alpha1.PlaybackService", 3013 3013 - "PlayAlbum", 3014 3014 - )); 3443 3443 + req.extensions_mut() 3444 3444 + .insert( 3445 3445 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAlbum"), 3446 3446 + ); 3015 3447 self.inner.unary(req, path, codec).await 3016 3448 } 3017 3449 pub async fn play_artist_tracks( 3018 3450 &mut self, 3019 3451 request: impl tonic::IntoRequest<super::PlayArtistTracksRequest>, 3020 3020 - ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status> 3021 3021 - { 3022 3022 - self.inner.ready().await.map_err(|e| { 3023 3023 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3024 3024 - })?; 3452 3452 + ) -> std::result::Result< 3453 3453 + tonic::Response<super::PlayArtistTracksResponse>, 3454 3454 + tonic::Status, 3455 3455 + > { 3456 3456 + self.inner 3457 3457 + .ready() 3458 3458 + .await 3459 3459 + .map_err(|e| { 3460 3460 + tonic::Status::unknown( 3461 3461 + format!("Service was not ready: {}", e.into()), 3462 3462 + ) 3463 3463 + })?; 3025 3464 let codec = tonic::codec::ProstCodec::default(); 3026 3465 let path = http::uri::PathAndQuery::from_static( 3027 3466 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks", 3028 3467 ); 3029 3468 let mut req = request.into_request(); 3030 3030 - req.extensions_mut().insert(GrpcMethod::new( 3031 3031 - "rockbox.v1alpha1.PlaybackService", 3032 3032 - "PlayArtistTracks", 3033 3033 - )); 3469 3469 + req.extensions_mut() 3470 3470 + .insert( 3471 3471 + GrpcMethod::new( 3472 3472 + "rockbox.v1alpha1.PlaybackService", 3473 3473 + "PlayArtistTracks", 3474 3474 + ), 3475 3475 + ); 3034 3476 self.inner.unary(req, path, codec).await 3035 3477 } 3036 3478 pub async fn play_playlist( 3037 3479 &mut self, 3038 3480 request: impl tonic::IntoRequest<super::PlayPlaylistRequest>, 3039 3039 - ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status> 3040 3040 - { 3041 3041 - self.inner.ready().await.map_err(|e| { 3042 3042 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3043 3043 - })?; 3481 3481 + ) -> std::result::Result< 3482 3482 + tonic::Response<super::PlayPlaylistResponse>, 3483 3483 + tonic::Status, 3484 3484 + > { 3485 3485 + self.inner 3486 3486 + .ready() 3487 3487 + .await 3488 3488 + .map_err(|e| { 3489 3489 + tonic::Status::unknown( 3490 3490 + format!("Service was not ready: {}", e.into()), 3491 3491 + ) 3492 3492 + })?; 3044 3493 let codec = tonic::codec::ProstCodec::default(); 3045 3494 let path = http::uri::PathAndQuery::from_static( 3046 3495 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist", 3047 3496 ); 3048 3497 let mut req = request.into_request(); 3049 3049 - req.extensions_mut().insert(GrpcMethod::new( 3050 3050 - "rockbox.v1alpha1.PlaybackService", 3051 3051 - "PlayPlaylist", 3052 3052 - )); 3498 3498 + req.extensions_mut() 3499 3499 + .insert( 3500 3500 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayPlaylist"), 3501 3501 + ); 3053 3502 self.inner.unary(req, path, codec).await 3054 3503 } 3055 3504 pub async fn play_directory( 3056 3505 &mut self, 3057 3506 request: impl tonic::IntoRequest<super::PlayDirectoryRequest>, 3058 3058 - ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status> 3059 3059 - { 3060 3060 - self.inner.ready().await.map_err(|e| { 3061 3061 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3062 3062 - })?; 3507 3507 + ) -> std::result::Result< 3508 3508 + tonic::Response<super::PlayDirectoryResponse>, 3509 3509 + tonic::Status, 3510 3510 + > { 3511 3511 + self.inner 3512 3512 + .ready() 3513 3513 + .await 3514 3514 + .map_err(|e| { 3515 3515 + tonic::Status::unknown( 3516 3516 + format!("Service was not ready: {}", e.into()), 3517 3517 + ) 3518 3518 + })?; 3063 3519 let codec = tonic::codec::ProstCodec::default(); 3064 3520 let path = http::uri::PathAndQuery::from_static( 3065 3521 "/rockbox.v1alpha1.PlaybackService/PlayDirectory", 3066 3522 ); 3067 3523 let mut req = request.into_request(); 3068 3068 - req.extensions_mut().insert(GrpcMethod::new( 3069 3069 - "rockbox.v1alpha1.PlaybackService", 3070 3070 - "PlayDirectory", 3071 3071 - )); 3524 3524 + req.extensions_mut() 3525 3525 + .insert( 3526 3526 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayDirectory"), 3527 3527 + ); 3072 3528 self.inner.unary(req, path, codec).await 3073 3529 } 3074 3530 pub async fn play_music_directory( 3075 3531 &mut self, 3076 3532 request: impl tonic::IntoRequest<super::PlayMusicDirectoryRequest>, 3077 3077 - ) -> std::result::Result<tonic::Response<super::PlayMusicDirectoryResponse>, tonic::Status> 3078 3078 - { 3079 3079 - self.inner.ready().await.map_err(|e| { 3080 3080 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3081 3081 - })?; 3533 3533 + ) -> std::result::Result< 3534 3534 + tonic::Response<super::PlayMusicDirectoryResponse>, 3535 3535 + tonic::Status, 3536 3536 + > { 3537 3537 + self.inner 3538 3538 + .ready() 3539 3539 + .await 3540 3540 + .map_err(|e| { 3541 3541 + tonic::Status::unknown( 3542 3542 + format!("Service was not ready: {}", e.into()), 3543 3543 + ) 3544 3544 + })?; 3082 3545 let codec = tonic::codec::ProstCodec::default(); 3083 3546 let path = http::uri::PathAndQuery::from_static( 3084 3547 "/rockbox.v1alpha1.PlaybackService/PlayMusicDirectory", 3085 3548 ); 3086 3549 let mut req = request.into_request(); 3087 3087 - req.extensions_mut().insert(GrpcMethod::new( 3088 3088 - "rockbox.v1alpha1.PlaybackService", 3089 3089 - "PlayMusicDirectory", 3090 3090 - )); 3550 3550 + req.extensions_mut() 3551 3551 + .insert( 3552 3552 + GrpcMethod::new( 3553 3553 + "rockbox.v1alpha1.PlaybackService", 3554 3554 + "PlayMusicDirectory", 3555 3555 + ), 3556 3556 + ); 3091 3557 self.inner.unary(req, path, codec).await 3092 3558 } 3093 3559 pub async fn play_track( 3094 3560 &mut self, 3095 3561 request: impl tonic::IntoRequest<super::PlayTrackRequest>, 3096 3096 - ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status> { 3097 3097 - self.inner.ready().await.map_err(|e| { 3098 3098 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3099 3099 - })?; 3562 3562 + ) -> std::result::Result< 3563 3563 + tonic::Response<super::PlayTrackResponse>, 3564 3564 + tonic::Status, 3565 3565 + > { 3566 3566 + self.inner 3567 3567 + .ready() 3568 3568 + .await 3569 3569 + .map_err(|e| { 3570 3570 + tonic::Status::unknown( 3571 3571 + format!("Service was not ready: {}", e.into()), 3572 3572 + ) 3573 3573 + })?; 3100 3574 let codec = tonic::codec::ProstCodec::default(); 3101 3101 - let path = 3102 3102 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayTrack"); 3575 3575 + let path = http::uri::PathAndQuery::from_static( 3576 3576 + "/rockbox.v1alpha1.PlaybackService/PlayTrack", 3577 3577 + ); 3103 3578 let mut req = request.into_request(); 3104 3104 - req.extensions_mut().insert(GrpcMethod::new( 3105 3105 - "rockbox.v1alpha1.PlaybackService", 3106 3106 - "PlayTrack", 3107 3107 - )); 3579 3579 + req.extensions_mut() 3580 3580 + .insert( 3581 3581 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayTrack"), 3582 3582 + ); 3108 3583 self.inner.unary(req, path, codec).await 3109 3584 } 3110 3585 pub async fn play_liked_tracks( 3111 3586 &mut self, 3112 3587 request: impl tonic::IntoRequest<super::PlayLikedTracksRequest>, 3113 3113 - ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status> 3114 3114 - { 3115 3115 - self.inner.ready().await.map_err(|e| { 3116 3116 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3117 3117 - })?; 3588 3588 + ) -> std::result::Result< 3589 3589 + tonic::Response<super::PlayLikedTracksResponse>, 3590 3590 + tonic::Status, 3591 3591 + > { 3592 3592 + self.inner 3593 3593 + .ready() 3594 3594 + .await 3595 3595 + .map_err(|e| { 3596 3596 + tonic::Status::unknown( 3597 3597 + format!("Service was not ready: {}", e.into()), 3598 3598 + ) 3599 3599 + })?; 3118 3600 let codec = tonic::codec::ProstCodec::default(); 3119 3601 let path = http::uri::PathAndQuery::from_static( 3120 3602 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks", 3121 3603 ); 3122 3604 let mut req = request.into_request(); 3123 3123 - req.extensions_mut().insert(GrpcMethod::new( 3124 3124 - "rockbox.v1alpha1.PlaybackService", 3125 3125 - "PlayLikedTracks", 3126 3126 - )); 3605 3605 + req.extensions_mut() 3606 3606 + .insert( 3607 3607 + GrpcMethod::new( 3608 3608 + "rockbox.v1alpha1.PlaybackService", 3609 3609 + "PlayLikedTracks", 3610 3610 + ), 3611 3611 + ); 3127 3612 self.inner.unary(req, path, codec).await 3128 3613 } 3129 3614 pub async fn play_all_tracks( 3130 3615 &mut self, 3131 3616 request: impl tonic::IntoRequest<super::PlayAllTracksRequest>, 3132 3132 - ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status> 3133 3133 - { 3134 3134 - self.inner.ready().await.map_err(|e| { 3135 3135 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3136 3136 - })?; 3617 3617 + ) -> std::result::Result< 3618 3618 + tonic::Response<super::PlayAllTracksResponse>, 3619 3619 + tonic::Status, 3620 3620 + > { 3621 3621 + self.inner 3622 3622 + .ready() 3623 3623 + .await 3624 3624 + .map_err(|e| { 3625 3625 + tonic::Status::unknown( 3626 3626 + format!("Service was not ready: {}", e.into()), 3627 3627 + ) 3628 3628 + })?; 3137 3629 let codec = tonic::codec::ProstCodec::default(); 3138 3630 let path = http::uri::PathAndQuery::from_static( 3139 3631 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks", 3140 3632 ); 3141 3633 let mut req = request.into_request(); 3142 3142 - req.extensions_mut().insert(GrpcMethod::new( 3143 3143 - "rockbox.v1alpha1.PlaybackService", 3144 3144 - "PlayAllTracks", 3145 3145 - )); 3634 3634 + req.extensions_mut() 3635 3635 + .insert( 3636 3636 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAllTracks"), 3637 3637 + ); 3146 3638 self.inner.unary(req, path, codec).await 3147 3639 } 3148 3640 pub async fn stream_current_track( ··· 3152 3644 tonic::Response<tonic::codec::Streaming<super::CurrentTrackResponse>>, 3153 3645 tonic::Status, 3154 3646 > { 3155 3155 - self.inner.ready().await.map_err(|e| { 3156 3156 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3157 3157 - })?; 3647 3647 + self.inner 3648 3648 + .ready() 3649 3649 + .await 3650 3650 + .map_err(|e| { 3651 3651 + tonic::Status::unknown( 3652 3652 + format!("Service was not ready: {}", e.into()), 3653 3653 + ) 3654 3654 + })?; 3158 3655 let codec = tonic::codec::ProstCodec::default(); 3159 3656 let path = http::uri::PathAndQuery::from_static( 3160 3657 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack", 3161 3658 ); 3162 3659 let mut req = request.into_request(); 3163 3163 - req.extensions_mut().insert(GrpcMethod::new( 3164 3164 - "rockbox.v1alpha1.PlaybackService", 3165 3165 - "StreamCurrentTrack", 3166 3166 - )); 3660 3660 + req.extensions_mut() 3661 3661 + .insert( 3662 3662 + GrpcMethod::new( 3663 3663 + "rockbox.v1alpha1.PlaybackService", 3664 3664 + "StreamCurrentTrack", 3665 3665 + ), 3666 3666 + ); 3167 3667 self.inner.server_streaming(req, path, codec).await 3168 3668 } 3169 3669 pub async fn stream_status( ··· 3173 3673 tonic::Response<tonic::codec::Streaming<super::StatusResponse>>, 3174 3674 tonic::Status, 3175 3675 > { 3176 3176 - self.inner.ready().await.map_err(|e| { 3177 3177 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3178 3178 - })?; 3676 3676 + self.inner 3677 3677 + .ready() 3678 3678 + .await 3679 3679 + .map_err(|e| { 3680 3680 + tonic::Status::unknown( 3681 3681 + format!("Service was not ready: {}", e.into()), 3682 3682 + ) 3683 3683 + })?; 3179 3684 let codec = tonic::codec::ProstCodec::default(); 3180 3685 let path = http::uri::PathAndQuery::from_static( 3181 3686 "/rockbox.v1alpha1.PlaybackService/StreamStatus", 3182 3687 ); 3183 3688 let mut req = request.into_request(); 3184 3184 - req.extensions_mut().insert(GrpcMethod::new( 3185 3185 - "rockbox.v1alpha1.PlaybackService", 3186 3186 - "StreamStatus", 3187 3187 - )); 3689 3689 + req.extensions_mut() 3690 3690 + .insert( 3691 3691 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamStatus"), 3692 3692 + ); 3188 3693 self.inner.server_streaming(req, path, codec).await 3189 3694 } 3190 3695 pub async fn stream_playlist( ··· 3194 3699 tonic::Response<tonic::codec::Streaming<super::PlaylistResponse>>, 3195 3700 tonic::Status, 3196 3701 > { 3197 3197 - self.inner.ready().await.map_err(|e| { 3198 3198 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3199 3199 - })?; 3702 3702 + self.inner 3703 3703 + .ready() 3704 3704 + .await 3705 3705 + .map_err(|e| { 3706 3706 + tonic::Status::unknown( 3707 3707 + format!("Service was not ready: {}", e.into()), 3708 3708 + ) 3709 3709 + })?; 3200 3710 let codec = tonic::codec::ProstCodec::default(); 3201 3711 let path = http::uri::PathAndQuery::from_static( 3202 3712 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist", 3203 3713 ); 3204 3714 let mut req = request.into_request(); 3205 3205 - req.extensions_mut().insert(GrpcMethod::new( 3206 3206 - "rockbox.v1alpha1.PlaybackService", 3207 3207 - "StreamPlaylist", 3208 3208 - )); 3715 3715 + req.extensions_mut() 3716 3716 + .insert( 3717 3717 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamPlaylist"), 3718 3718 + ); 3209 3719 self.inner.server_streaming(req, path, codec).await 3210 3720 } 3211 3721 } ··· 3217 3727 dead_code, 3218 3728 missing_docs, 3219 3729 clippy::wildcard_imports, 3220 3220 - clippy::let_unit_value 3730 3730 + clippy::let_unit_value, 3221 3731 )] 3222 3732 use tonic::codegen::*; 3223 3733 /// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer. ··· 3234 3744 async fn play_or_pause( 3235 3745 &self, 3236 3746 request: tonic::Request<super::PlayOrPauseRequest>, 3237 3237 - ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status>; 3747 3747 + ) -> std::result::Result< 3748 3748 + tonic::Response<super::PlayOrPauseResponse>, 3749 3749 + tonic::Status, 3750 3750 + >; 3238 3751 async fn resume( 3239 3752 &self, 3240 3753 request: tonic::Request<super::ResumeRequest>, ··· 3246 3759 async fn previous( 3247 3760 &self, 3248 3761 request: tonic::Request<super::PreviousRequest>, 3249 3249 - ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status>; 3762 3762 + ) -> std::result::Result< 3763 3763 + tonic::Response<super::PreviousResponse>, 3764 3764 + tonic::Status, 3765 3765 + >; 3250 3766 async fn fast_forward_rewind( 3251 3767 &self, 3252 3768 request: tonic::Request<super::FastForwardRewindRequest>, 3253 3253 - ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>; 3769 3769 + ) -> std::result::Result< 3770 3770 + tonic::Response<super::FastForwardRewindResponse>, 3771 3771 + tonic::Status, 3772 3772 + >; 3254 3773 async fn status( 3255 3774 &self, 3256 3775 request: tonic::Request<super::StatusRequest>, ··· 3258 3777 async fn current_track( 3259 3778 &self, 3260 3779 request: tonic::Request<super::CurrentTrackRequest>, 3261 3261 - ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status>; 3780 3780 + ) -> std::result::Result< 3781 3781 + tonic::Response<super::CurrentTrackResponse>, 3782 3782 + tonic::Status, 3783 3783 + >; 3262 3784 async fn next_track( 3263 3785 &self, 3264 3786 request: tonic::Request<super::NextTrackRequest>, 3265 3265 - ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status>; 3787 3787 + ) -> std::result::Result< 3788 3788 + tonic::Response<super::NextTrackResponse>, 3789 3789 + tonic::Status, 3790 3790 + >; 3266 3791 async fn flush_and_reload_tracks( 3267 3792 &self, 3268 3793 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3269 3269 - ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status>; 3794 3794 + ) -> std::result::Result< 3795 3795 + tonic::Response<super::FlushAndReloadTracksResponse>, 3796 3796 + tonic::Status, 3797 3797 + >; 3270 3798 async fn get_file_position( 3271 3799 &self, 3272 3800 request: tonic::Request<super::GetFilePositionRequest>, 3273 3273 - ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status>; 3801 3801 + ) -> std::result::Result< 3802 3802 + tonic::Response<super::GetFilePositionResponse>, 3803 3803 + tonic::Status, 3804 3804 + >; 3274 3805 async fn hard_stop( 3275 3806 &self, 3276 3807 request: tonic::Request<super::HardStopRequest>, 3277 3277 - ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status>; 3808 3808 + ) -> std::result::Result< 3809 3809 + tonic::Response<super::HardStopResponse>, 3810 3810 + tonic::Status, 3811 3811 + >; 3278 3812 async fn play_album( 3279 3813 &self, 3280 3814 request: tonic::Request<super::PlayAlbumRequest>, 3281 3281 - ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status>; 3815 3815 + ) -> std::result::Result< 3816 3816 + tonic::Response<super::PlayAlbumResponse>, 3817 3817 + tonic::Status, 3818 3818 + >; 3282 3819 async fn play_artist_tracks( 3283 3820 &self, 3284 3821 request: tonic::Request<super::PlayArtistTracksRequest>, 3285 3285 - ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status>; 3822 3822 + ) -> std::result::Result< 3823 3823 + tonic::Response<super::PlayArtistTracksResponse>, 3824 3824 + tonic::Status, 3825 3825 + >; 3286 3826 async fn play_playlist( 3287 3827 &self, 3288 3828 request: tonic::Request<super::PlayPlaylistRequest>, 3289 3289 - ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status>; 3829 3829 + ) -> std::result::Result< 3830 3830 + tonic::Response<super::PlayPlaylistResponse>, 3831 3831 + tonic::Status, 3832 3832 + >; 3290 3833 async fn play_directory( 3291 3834 &self, 3292 3835 request: tonic::Request<super::PlayDirectoryRequest>, 3293 3293 - ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>; 3836 3836 + ) -> std::result::Result< 3837 3837 + tonic::Response<super::PlayDirectoryResponse>, 3838 3838 + tonic::Status, 3839 3839 + >; 3294 3840 async fn play_music_directory( 3295 3841 &self, 3296 3842 request: tonic::Request<super::PlayMusicDirectoryRequest>, 3297 3297 - ) -> std::result::Result<tonic::Response<super::PlayMusicDirectoryResponse>, tonic::Status>; 3843 3843 + ) -> std::result::Result< 3844 3844 + tonic::Response<super::PlayMusicDirectoryResponse>, 3845 3845 + tonic::Status, 3846 3846 + >; 3298 3847 async fn play_track( 3299 3848 &self, 3300 3849 request: tonic::Request<super::PlayTrackRequest>, 3301 3301 - ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status>; 3850 3850 + ) -> std::result::Result< 3851 3851 + tonic::Response<super::PlayTrackResponse>, 3852 3852 + tonic::Status, 3853 3853 + >; 3302 3854 async fn play_liked_tracks( 3303 3855 &self, 3304 3856 request: tonic::Request<super::PlayLikedTracksRequest>, 3305 3305 - ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status>; 3857 3857 + ) -> std::result::Result< 3858 3858 + tonic::Response<super::PlayLikedTracksResponse>, 3859 3859 + tonic::Status, 3860 3860 + >; 3306 3861 async fn play_all_tracks( 3307 3862 &self, 3308 3863 request: tonic::Request<super::PlayAllTracksRequest>, 3309 3309 - ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>; 3864 3864 + ) -> std::result::Result< 3865 3865 + tonic::Response<super::PlayAllTracksResponse>, 3866 3866 + tonic::Status, 3867 3867 + >; 3310 3868 /// Server streaming response type for the StreamCurrentTrack method. 3311 3869 type StreamCurrentTrackStream: tonic::codegen::tokio_stream::Stream< 3312 3870 Item = std::result::Result<super::CurrentTrackResponse, tonic::Status>, 3313 3313 - > + std::marker::Send 3871 3871 + > 3872 3872 + + std::marker::Send 3314 3873 + 'static; 3315 3874 async fn stream_current_track( 3316 3875 &self, 3317 3876 request: tonic::Request<super::StreamCurrentTrackRequest>, 3318 3318 - ) -> std::result::Result<tonic::Response<Self::StreamCurrentTrackStream>, tonic::Status>; 3877 3877 + ) -> std::result::Result< 3878 3878 + tonic::Response<Self::StreamCurrentTrackStream>, 3879 3879 + tonic::Status, 3880 3880 + >; 3319 3881 /// Server streaming response type for the StreamStatus method. 3320 3882 type StreamStatusStream: tonic::codegen::tokio_stream::Stream< 3321 3883 Item = std::result::Result<super::StatusResponse, tonic::Status>, 3322 3322 - > + std::marker::Send 3884 3884 + > 3885 3885 + + std::marker::Send 3323 3886 + 'static; 3324 3887 async fn stream_status( 3325 3888 &self, 3326 3889 request: tonic::Request<super::StreamStatusRequest>, 3327 3327 - ) -> std::result::Result<tonic::Response<Self::StreamStatusStream>, tonic::Status>; 3890 3890 + ) -> std::result::Result< 3891 3891 + tonic::Response<Self::StreamStatusStream>, 3892 3892 + tonic::Status, 3893 3893 + >; 3328 3894 /// Server streaming response type for the StreamPlaylist method. 3329 3895 type StreamPlaylistStream: tonic::codegen::tokio_stream::Stream< 3330 3896 Item = std::result::Result<super::PlaylistResponse, tonic::Status>, 3331 3331 - > + std::marker::Send 3897 3897 + > 3898 3898 + + std::marker::Send 3332 3899 + 'static; 3333 3900 async fn stream_playlist( 3334 3901 &self, 3335 3902 request: tonic::Request<super::StreamPlaylistRequest>, 3336 3336 - ) -> std::result::Result<tonic::Response<Self::StreamPlaylistStream>, tonic::Status>; 3903 3903 + ) -> std::result::Result< 3904 3904 + tonic::Response<Self::StreamPlaylistStream>, 3905 3905 + tonic::Status, 3906 3906 + >; 3337 3907 } 3338 3908 #[derive(Debug)] 3339 3909 pub struct PlaybackServiceServer<T> { ··· 3356 3926 max_encoding_message_size: None, 3357 3927 } 3358 3928 } 3359 3359 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 3929 3929 + pub fn with_interceptor<F>( 3930 3930 + inner: T, 3931 3931 + interceptor: F, 3932 3932 + ) -> InterceptedService<Self, F> 3360 3933 where 3361 3934 F: tonic::service::Interceptor, 3362 3935 { ··· 3411 3984 "/rockbox.v1alpha1.PlaybackService/Play" => { 3412 3985 #[allow(non_camel_case_types)] 3413 3986 struct PlaySvc<T: PlaybackService>(pub Arc<T>); 3414 3414 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 3987 3987 + impl< 3988 3988 + T: PlaybackService, 3989 3989 + > tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 3415 3990 type Response = super::PlayResponse; 3416 3416 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3991 3991 + type Future = BoxFuture< 3992 3992 + tonic::Response<Self::Response>, 3993 3993 + tonic::Status, 3994 3994 + >; 3417 3995 fn call( 3418 3996 &mut self, 3419 3997 request: tonic::Request<super::PlayRequest>, 3420 3998 ) -> Self::Future { 3421 3999 let inner = Arc::clone(&self.0); 3422 3422 - let fut = 3423 3423 - async move { <T as PlaybackService>::play(&inner, request).await }; 4000 4000 + let fut = async move { 4001 4001 + <T as PlaybackService>::play(&inner, request).await 4002 4002 + }; 3424 4003 Box::pin(fut) 3425 4004 } 3426 4005 } ··· 3449 4028 "/rockbox.v1alpha1.PlaybackService/Pause" => { 3450 4029 #[allow(non_camel_case_types)] 3451 4030 struct PauseSvc<T: PlaybackService>(pub Arc<T>); 3452 3452 - impl<T: PlaybackService> tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 4031 4031 + impl< 4032 4032 + T: PlaybackService, 4033 4033 + > tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 3453 4034 type Response = super::PauseResponse; 3454 3454 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4035 4035 + type Future = BoxFuture< 4036 4036 + tonic::Response<Self::Response>, 4037 4037 + tonic::Status, 4038 4038 + >; 3455 4039 fn call( 3456 4040 &mut self, 3457 4041 request: tonic::Request<super::PauseRequest>, 3458 4042 ) -> Self::Future { 3459 4043 let inner = Arc::clone(&self.0); 3460 3460 - let fut = 3461 3461 - async move { <T as PlaybackService>::pause(&inner, request).await }; 4044 4044 + let fut = async move { 4045 4045 + <T as PlaybackService>::pause(&inner, request).await 4046 4046 + }; 3462 4047 Box::pin(fut) 3463 4048 } 3464 4049 } ··· 3487 4072 "/rockbox.v1alpha1.PlaybackService/PlayOrPause" => { 3488 4073 #[allow(non_camel_case_types)] 3489 4074 struct PlayOrPauseSvc<T: PlaybackService>(pub Arc<T>); 3490 3490 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayOrPauseRequest> 3491 3491 - for PlayOrPauseSvc<T> 3492 3492 - { 4075 4075 + impl< 4076 4076 + T: PlaybackService, 4077 4077 + > tonic::server::UnaryService<super::PlayOrPauseRequest> 4078 4078 + for PlayOrPauseSvc<T> { 3493 4079 type Response = super::PlayOrPauseResponse; 3494 3494 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4080 4080 + type Future = BoxFuture< 4081 4081 + tonic::Response<Self::Response>, 4082 4082 + tonic::Status, 4083 4083 + >; 3495 4084 fn call( 3496 4085 &mut self, 3497 4086 request: tonic::Request<super::PlayOrPauseRequest>, ··· 3528 4117 "/rockbox.v1alpha1.PlaybackService/Resume" => { 3529 4118 #[allow(non_camel_case_types)] 3530 4119 struct ResumeSvc<T: PlaybackService>(pub Arc<T>); 3531 3531 - impl<T: PlaybackService> tonic::server::UnaryService<super::ResumeRequest> for ResumeSvc<T> { 4120 4120 + impl< 4121 4121 + T: PlaybackService, 4122 4122 + > tonic::server::UnaryService<super::ResumeRequest> 4123 4123 + for ResumeSvc<T> { 3532 4124 type Response = super::ResumeResponse; 3533 3533 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4125 4125 + type Future = BoxFuture< 4126 4126 + tonic::Response<Self::Response>, 4127 4127 + tonic::Status, 4128 4128 + >; 3534 4129 fn call( 3535 4130 &mut self, 3536 4131 request: tonic::Request<super::ResumeRequest>, ··· 3567 4162 "/rockbox.v1alpha1.PlaybackService/Next" => { 3568 4163 #[allow(non_camel_case_types)] 3569 4164 struct NextSvc<T: PlaybackService>(pub Arc<T>); 3570 3570 - impl<T: PlaybackService> tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 4165 4165 + impl< 4166 4166 + T: PlaybackService, 4167 4167 + > tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 3571 4168 type Response = super::NextResponse; 3572 3572 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4169 4169 + type Future = BoxFuture< 4170 4170 + tonic::Response<Self::Response>, 4171 4171 + tonic::Status, 4172 4172 + >; 3573 4173 fn call( 3574 4174 &mut self, 3575 4175 request: tonic::Request<super::NextRequest>, 3576 4176 ) -> Self::Future { 3577 4177 let inner = Arc::clone(&self.0); 3578 3578 - let fut = 3579 3579 - async move { <T as PlaybackService>::next(&inner, request).await }; 4178 4178 + let fut = async move { 4179 4179 + <T as PlaybackService>::next(&inner, request).await 4180 4180 + }; 3580 4181 Box::pin(fut) 3581 4182 } 3582 4183 } ··· 3605 4206 "/rockbox.v1alpha1.PlaybackService/Previous" => { 3606 4207 #[allow(non_camel_case_types)] 3607 4208 struct PreviousSvc<T: PlaybackService>(pub Arc<T>); 3608 3608 - impl<T: PlaybackService> tonic::server::UnaryService<super::PreviousRequest> for PreviousSvc<T> { 4209 4209 + impl< 4210 4210 + T: PlaybackService, 4211 4211 + > tonic::server::UnaryService<super::PreviousRequest> 4212 4212 + for PreviousSvc<T> { 3609 4213 type Response = super::PreviousResponse; 3610 3610 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4214 4214 + type Future = BoxFuture< 4215 4215 + tonic::Response<Self::Response>, 4216 4216 + tonic::Status, 4217 4217 + >; 3611 4218 fn call( 3612 4219 &mut self, 3613 4220 request: tonic::Request<super::PreviousRequest>, ··· 3644 4251 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind" => { 3645 4252 #[allow(non_camel_case_types)] 3646 4253 struct FastForwardRewindSvc<T: PlaybackService>(pub Arc<T>); 3647 3647 - impl<T: PlaybackService> 3648 3648 - tonic::server::UnaryService<super::FastForwardRewindRequest> 3649 3649 - for FastForwardRewindSvc<T> 3650 3650 - { 4254 4254 + impl< 4255 4255 + T: PlaybackService, 4256 4256 + > tonic::server::UnaryService<super::FastForwardRewindRequest> 4257 4257 + for FastForwardRewindSvc<T> { 3651 4258 type Response = super::FastForwardRewindResponse; 3652 3652 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4259 4259 + type Future = BoxFuture< 4260 4260 + tonic::Response<Self::Response>, 4261 4261 + tonic::Status, 4262 4262 + >; 3653 4263 fn call( 3654 4264 &mut self, 3655 4265 request: tonic::Request<super::FastForwardRewindRequest>, 3656 4266 ) -> Self::Future { 3657 4267 let inner = Arc::clone(&self.0); 3658 4268 let fut = async move { 3659 3659 - <T as PlaybackService>::fast_forward_rewind(&inner, request).await 4269 4269 + <T as PlaybackService>::fast_forward_rewind(&inner, request) 4270 4270 + .await 3660 4271 }; 3661 4272 Box::pin(fut) 3662 4273 } ··· 3686 4297 "/rockbox.v1alpha1.PlaybackService/Status" => { 3687 4298 #[allow(non_camel_case_types)] 3688 4299 struct StatusSvc<T: PlaybackService>(pub Arc<T>); 3689 3689 - impl<T: PlaybackService> tonic::server::UnaryService<super::StatusRequest> for StatusSvc<T> { 4300 4300 + impl< 4301 4301 + T: PlaybackService, 4302 4302 + > tonic::server::UnaryService<super::StatusRequest> 4303 4303 + for StatusSvc<T> { 3690 4304 type Response = super::StatusResponse; 3691 3691 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4305 4305 + type Future = BoxFuture< 4306 4306 + tonic::Response<Self::Response>, 4307 4307 + tonic::Status, 4308 4308 + >; 3692 4309 fn call( 3693 4310 &mut self, 3694 4311 request: tonic::Request<super::StatusRequest>, ··· 3725 4342 "/rockbox.v1alpha1.PlaybackService/CurrentTrack" => { 3726 4343 #[allow(non_camel_case_types)] 3727 4344 struct CurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 3728 3728 - impl<T: PlaybackService> tonic::server::UnaryService<super::CurrentTrackRequest> 3729 3729 - for CurrentTrackSvc<T> 3730 3730 - { 4345 4345 + impl< 4346 4346 + T: PlaybackService, 4347 4347 + > tonic::server::UnaryService<super::CurrentTrackRequest> 4348 4348 + for CurrentTrackSvc<T> { 3731 4349 type Response = super::CurrentTrackResponse; 3732 3732 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4350 4350 + type Future = BoxFuture< 4351 4351 + tonic::Response<Self::Response>, 4352 4352 + tonic::Status, 4353 4353 + >; 3733 4354 fn call( 3734 4355 &mut self, 3735 4356 request: tonic::Request<super::CurrentTrackRequest>, ··· 3766 4387 "/rockbox.v1alpha1.PlaybackService/NextTrack" => { 3767 4388 #[allow(non_camel_case_types)] 3768 4389 struct NextTrackSvc<T: PlaybackService>(pub Arc<T>); 3769 3769 - impl<T: PlaybackService> tonic::server::UnaryService<super::NextTrackRequest> for NextTrackSvc<T> { 4390 4390 + impl< 4391 4391 + T: PlaybackService, 4392 4392 + > tonic::server::UnaryService<super::NextTrackRequest> 4393 4393 + for NextTrackSvc<T> { 3770 4394 type Response = super::NextTrackResponse; 3771 3771 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4395 4395 + type Future = BoxFuture< 4396 4396 + tonic::Response<Self::Response>, 4397 4397 + tonic::Status, 4398 4398 + >; 3772 4399 fn call( 3773 4400 &mut self, 3774 4401 request: tonic::Request<super::NextTrackRequest>, ··· 3805 4432 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks" => { 3806 4433 #[allow(non_camel_case_types)] 3807 4434 struct FlushAndReloadTracksSvc<T: PlaybackService>(pub Arc<T>); 3808 3808 - impl<T: PlaybackService> 3809 3809 - tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3810 3810 - for FlushAndReloadTracksSvc<T> 3811 3811 - { 4435 4435 + impl< 4436 4436 + T: PlaybackService, 4437 4437 + > tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 4438 4438 + for FlushAndReloadTracksSvc<T> { 3812 4439 type Response = super::FlushAndReloadTracksResponse; 3813 3813 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4440 4440 + type Future = BoxFuture< 4441 4441 + tonic::Response<Self::Response>, 4442 4442 + tonic::Status, 4443 4443 + >; 3814 4444 fn call( 3815 4445 &mut self, 3816 4446 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3817 4447 ) -> Self::Future { 3818 4448 let inner = Arc::clone(&self.0); 3819 4449 let fut = async move { 3820 3820 - <T as PlaybackService>::flush_and_reload_tracks(&inner, request) 4450 4450 + <T as PlaybackService>::flush_and_reload_tracks( 4451 4451 + &inner, 4452 4452 + request, 4453 4453 + ) 3821 4454 .await 3822 4455 }; 3823 4456 Box::pin(fut) ··· 3848 4481 "/rockbox.v1alpha1.PlaybackService/GetFilePosition" => { 3849 4482 #[allow(non_camel_case_types)] 3850 4483 struct GetFilePositionSvc<T: PlaybackService>(pub Arc<T>); 3851 3851 - impl<T: PlaybackService> 3852 3852 - tonic::server::UnaryService<super::GetFilePositionRequest> 3853 3853 - for GetFilePositionSvc<T> 3854 3854 - { 4484 4484 + impl< 4485 4485 + T: PlaybackService, 4486 4486 + > tonic::server::UnaryService<super::GetFilePositionRequest> 4487 4487 + for GetFilePositionSvc<T> { 3855 4488 type Response = super::GetFilePositionResponse; 3856 3856 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4489 4489 + type Future = BoxFuture< 4490 4490 + tonic::Response<Self::Response>, 4491 4491 + tonic::Status, 4492 4492 + >; 3857 4493 fn call( 3858 4494 &mut self, 3859 4495 request: tonic::Request<super::GetFilePositionRequest>, 3860 4496 ) -> Self::Future { 3861 4497 let inner = Arc::clone(&self.0); 3862 4498 let fut = async move { 3863 3863 - <T as PlaybackService>::get_file_position(&inner, request).await 4499 4499 + <T as PlaybackService>::get_file_position(&inner, request) 4500 4500 + .await 3864 4501 }; 3865 4502 Box::pin(fut) 3866 4503 } ··· 3890 4527 "/rockbox.v1alpha1.PlaybackService/HardStop" => { 3891 4528 #[allow(non_camel_case_types)] 3892 4529 struct HardStopSvc<T: PlaybackService>(pub Arc<T>); 3893 3893 - impl<T: PlaybackService> tonic::server::UnaryService<super::HardStopRequest> for HardStopSvc<T> { 4530 4530 + impl< 4531 4531 + T: PlaybackService, 4532 4532 + > tonic::server::UnaryService<super::HardStopRequest> 4533 4533 + for HardStopSvc<T> { 3894 4534 type Response = super::HardStopResponse; 3895 3895 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4535 4535 + type Future = BoxFuture< 4536 4536 + tonic::Response<Self::Response>, 4537 4537 + tonic::Status, 4538 4538 + >; 3896 4539 fn call( 3897 4540 &mut self, 3898 4541 request: tonic::Request<super::HardStopRequest>, ··· 3929 4572 "/rockbox.v1alpha1.PlaybackService/PlayAlbum" => { 3930 4573 #[allow(non_camel_case_types)] 3931 4574 struct PlayAlbumSvc<T: PlaybackService>(pub Arc<T>); 3932 3932 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayAlbumRequest> for PlayAlbumSvc<T> { 4575 4575 + impl< 4576 4576 + T: PlaybackService, 4577 4577 + > tonic::server::UnaryService<super::PlayAlbumRequest> 4578 4578 + for PlayAlbumSvc<T> { 3933 4579 type Response = super::PlayAlbumResponse; 3934 3934 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4580 4580 + type Future = BoxFuture< 4581 4581 + tonic::Response<Self::Response>, 4582 4582 + tonic::Status, 4583 4583 + >; 3935 4584 fn call( 3936 4585 &mut self, 3937 4586 request: tonic::Request<super::PlayAlbumRequest>, ··· 3968 4617 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks" => { 3969 4618 #[allow(non_camel_case_types)] 3970 4619 struct PlayArtistTracksSvc<T: PlaybackService>(pub Arc<T>); 3971 3971 - impl<T: PlaybackService> 3972 3972 - tonic::server::UnaryService<super::PlayArtistTracksRequest> 3973 3973 - for PlayArtistTracksSvc<T> 3974 3974 - { 4620 4620 + impl< 4621 4621 + T: PlaybackService, 4622 4622 + > tonic::server::UnaryService<super::PlayArtistTracksRequest> 4623 4623 + for PlayArtistTracksSvc<T> { 3975 4624 type Response = super::PlayArtistTracksResponse; 3976 3976 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4625 4625 + type Future = BoxFuture< 4626 4626 + tonic::Response<Self::Response>, 4627 4627 + tonic::Status, 4628 4628 + >; 3977 4629 fn call( 3978 4630 &mut self, 3979 4631 request: tonic::Request<super::PlayArtistTracksRequest>, 3980 4632 ) -> Self::Future { 3981 4633 let inner = Arc::clone(&self.0); 3982 4634 let fut = async move { 3983 3983 - <T as PlaybackService>::play_artist_tracks(&inner, request).await 4635 4635 + <T as PlaybackService>::play_artist_tracks(&inner, request) 4636 4636 + .await 3984 4637 }; 3985 4638 Box::pin(fut) 3986 4639 } ··· 4010 4663 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist" => { 4011 4664 #[allow(non_camel_case_types)] 4012 4665 struct PlayPlaylistSvc<T: PlaybackService>(pub Arc<T>); 4013 4013 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayPlaylistRequest> 4014 4014 - for PlayPlaylistSvc<T> 4015 4015 - { 4666 4666 + impl< 4667 4667 + T: PlaybackService, 4668 4668 + > tonic::server::UnaryService<super::PlayPlaylistRequest> 4669 4669 + for PlayPlaylistSvc<T> { 4016 4670 type Response = super::PlayPlaylistResponse; 4017 4017 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4671 4671 + type Future = BoxFuture< 4672 4672 + tonic::Response<Self::Response>, 4673 4673 + tonic::Status, 4674 4674 + >; 4018 4675 fn call( 4019 4676 &mut self, 4020 4677 request: tonic::Request<super::PlayPlaylistRequest>, ··· 4051 4708 "/rockbox.v1alpha1.PlaybackService/PlayDirectory" => { 4052 4709 #[allow(non_camel_case_types)] 4053 4710 struct PlayDirectorySvc<T: PlaybackService>(pub Arc<T>); 4054 4054 - impl<T: PlaybackService> 4055 4055 - tonic::server::UnaryService<super::PlayDirectoryRequest> 4056 4056 - for PlayDirectorySvc<T> 4057 4057 - { 4711 4711 + impl< 4712 4712 + T: PlaybackService, 4713 4713 + > tonic::server::UnaryService<super::PlayDirectoryRequest> 4714 4714 + for PlayDirectorySvc<T> { 4058 4715 type Response = super::PlayDirectoryResponse; 4059 4059 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4716 4716 + type Future = BoxFuture< 4717 4717 + tonic::Response<Self::Response>, 4718 4718 + tonic::Status, 4719 4719 + >; 4060 4720 fn call( 4061 4721 &mut self, 4062 4722 request: tonic::Request<super::PlayDirectoryRequest>, 4063 4723 ) -> Self::Future { 4064 4724 let inner = Arc::clone(&self.0); 4065 4725 let fut = async move { 4066 4066 - <T as PlaybackService>::play_directory(&inner, request).await 4726 4726 + <T as PlaybackService>::play_directory(&inner, request) 4727 4727 + .await 4067 4728 }; 4068 4729 Box::pin(fut) 4069 4730 } ··· 4093 4754 "/rockbox.v1alpha1.PlaybackService/PlayMusicDirectory" => { 4094 4755 #[allow(non_camel_case_types)] 4095 4756 struct PlayMusicDirectorySvc<T: PlaybackService>(pub Arc<T>); 4096 4096 - impl<T: PlaybackService> 4097 4097 - tonic::server::UnaryService<super::PlayMusicDirectoryRequest> 4098 4098 - for PlayMusicDirectorySvc<T> 4099 4099 - { 4757 4757 + impl< 4758 4758 + T: PlaybackService, 4759 4759 + > tonic::server::UnaryService<super::PlayMusicDirectoryRequest> 4760 4760 + for PlayMusicDirectorySvc<T> { 4100 4761 type Response = super::PlayMusicDirectoryResponse; 4101 4101 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4762 4762 + type Future = BoxFuture< 4763 4763 + tonic::Response<Self::Response>, 4764 4764 + tonic::Status, 4765 4765 + >; 4102 4766 fn call( 4103 4767 &mut self, 4104 4768 request: tonic::Request<super::PlayMusicDirectoryRequest>, 4105 4769 ) -> Self::Future { 4106 4770 let inner = Arc::clone(&self.0); 4107 4771 let fut = async move { 4108 4108 - <T as PlaybackService>::play_music_directory(&inner, request).await 4772 4772 + <T as PlaybackService>::play_music_directory( 4773 4773 + &inner, 4774 4774 + request, 4775 4775 + ) 4776 4776 + .await 4109 4777 }; 4110 4778 Box::pin(fut) 4111 4779 } ··· 4135 4803 "/rockbox.v1alpha1.PlaybackService/PlayTrack" => { 4136 4804 #[allow(non_camel_case_types)] 4137 4805 struct PlayTrackSvc<T: PlaybackService>(pub Arc<T>); 4138 4138 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayTrackRequest> for PlayTrackSvc<T> { 4806 4806 + impl< 4807 4807 + T: PlaybackService, 4808 4808 + > tonic::server::UnaryService<super::PlayTrackRequest> 4809 4809 + for PlayTrackSvc<T> { 4139 4810 type Response = super::PlayTrackResponse; 4140 4140 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4811 4811 + type Future = BoxFuture< 4812 4812 + tonic::Response<Self::Response>, 4813 4813 + tonic::Status, 4814 4814 + >; 4141 4815 fn call( 4142 4816 &mut self, 4143 4817 request: tonic::Request<super::PlayTrackRequest>, ··· 4174 4848 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks" => { 4175 4849 #[allow(non_camel_case_types)] 4176 4850 struct PlayLikedTracksSvc<T: PlaybackService>(pub Arc<T>); 4177 4177 - impl<T: PlaybackService> 4178 4178 - tonic::server::UnaryService<super::PlayLikedTracksRequest> 4179 4179 - for PlayLikedTracksSvc<T> 4180 4180 - { 4851 4851 + impl< 4852 4852 + T: PlaybackService, 4853 4853 + > tonic::server::UnaryService<super::PlayLikedTracksRequest> 4854 4854 + for PlayLikedTracksSvc<T> { 4181 4855 type Response = super::PlayLikedTracksResponse; 4182 4182 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4856 4856 + type Future = BoxFuture< 4857 4857 + tonic::Response<Self::Response>, 4858 4858 + tonic::Status, 4859 4859 + >; 4183 4860 fn call( 4184 4861 &mut self, 4185 4862 request: tonic::Request<super::PlayLikedTracksRequest>, 4186 4863 ) -> Self::Future { 4187 4864 let inner = Arc::clone(&self.0); 4188 4865 let fut = async move { 4189 4189 - <T as PlaybackService>::play_liked_tracks(&inner, request).await 4866 4866 + <T as PlaybackService>::play_liked_tracks(&inner, request) 4867 4867 + .await 4190 4868 }; 4191 4869 Box::pin(fut) 4192 4870 } ··· 4216 4894 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks" => { 4217 4895 #[allow(non_camel_case_types)] 4218 4896 struct PlayAllTracksSvc<T: PlaybackService>(pub Arc<T>); 4219 4219 - impl<T: PlaybackService> 4220 4220 - tonic::server::UnaryService<super::PlayAllTracksRequest> 4221 4221 - for PlayAllTracksSvc<T> 4222 4222 - { 4897 4897 + impl< 4898 4898 + T: PlaybackService, 4899 4899 + > tonic::server::UnaryService<super::PlayAllTracksRequest> 4900 4900 + for PlayAllTracksSvc<T> { 4223 4901 type Response = super::PlayAllTracksResponse; 4224 4224 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4902 4902 + type Future = BoxFuture< 4903 4903 + tonic::Response<Self::Response>, 4904 4904 + tonic::Status, 4905 4905 + >; 4225 4906 fn call( 4226 4907 &mut self, 4227 4908 request: tonic::Request<super::PlayAllTracksRequest>, 4228 4909 ) -> Self::Future { 4229 4910 let inner = Arc::clone(&self.0); 4230 4911 let fut = async move { 4231 4231 - <T as PlaybackService>::play_all_tracks(&inner, request).await 4912 4912 + <T as PlaybackService>::play_all_tracks(&inner, request) 4913 4913 + .await 4232 4914 }; 4233 4915 Box::pin(fut) 4234 4916 } ··· 4258 4940 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack" => { 4259 4941 #[allow(non_camel_case_types)] 4260 4942 struct StreamCurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 4261 4261 - impl<T: PlaybackService> 4262 4262 - tonic::server::ServerStreamingService<super::StreamCurrentTrackRequest> 4263 4263 - for StreamCurrentTrackSvc<T> 4264 4264 - { 4943 4943 + impl< 4944 4944 + T: PlaybackService, 4945 4945 + > tonic::server::ServerStreamingService< 4946 4946 + super::StreamCurrentTrackRequest, 4947 4947 + > for StreamCurrentTrackSvc<T> { 4265 4948 type Response = super::CurrentTrackResponse; 4266 4949 type ResponseStream = T::StreamCurrentTrackStream; 4267 4267 - type Future = 4268 4268 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4950 4950 + type Future = BoxFuture< 4951 4951 + tonic::Response<Self::ResponseStream>, 4952 4952 + tonic::Status, 4953 4953 + >; 4269 4954 fn call( 4270 4955 &mut self, 4271 4956 request: tonic::Request<super::StreamCurrentTrackRequest>, 4272 4957 ) -> Self::Future { 4273 4958 let inner = Arc::clone(&self.0); 4274 4959 let fut = async move { 4275 4275 - <T as PlaybackService>::stream_current_track(&inner, request).await 4960 4960 + <T as PlaybackService>::stream_current_track( 4961 4961 + &inner, 4962 4962 + request, 4963 4963 + ) 4964 4964 + .await 4276 4965 }; 4277 4966 Box::pin(fut) 4278 4967 } ··· 4302 4991 "/rockbox.v1alpha1.PlaybackService/StreamStatus" => { 4303 4992 #[allow(non_camel_case_types)] 4304 4993 struct StreamStatusSvc<T: PlaybackService>(pub Arc<T>); 4305 4305 - impl<T: PlaybackService> 4306 4306 - tonic::server::ServerStreamingService<super::StreamStatusRequest> 4307 4307 - for StreamStatusSvc<T> 4308 4308 - { 4994 4994 + impl< 4995 4995 + T: PlaybackService, 4996 4996 + > tonic::server::ServerStreamingService<super::StreamStatusRequest> 4997 4997 + for StreamStatusSvc<T> { 4309 4998 type Response = super::StatusResponse; 4310 4999 type ResponseStream = T::StreamStatusStream; 4311 4311 - type Future = 4312 4312 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 5000 5000 + type Future = BoxFuture< 5001 5001 + tonic::Response<Self::ResponseStream>, 5002 5002 + tonic::Status, 5003 5003 + >; 4313 5004 fn call( 4314 5005 &mut self, 4315 5006 request: tonic::Request<super::StreamStatusRequest>, ··· 4346 5037 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist" => { 4347 5038 #[allow(non_camel_case_types)] 4348 5039 struct StreamPlaylistSvc<T: PlaybackService>(pub Arc<T>); 4349 4349 - impl<T: PlaybackService> 4350 4350 - tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 4351 4351 - for StreamPlaylistSvc<T> 4352 4352 - { 5040 5040 + impl< 5041 5041 + T: PlaybackService, 5042 5042 + > tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 5043 5043 + for StreamPlaylistSvc<T> { 4353 5044 type Response = super::PlaylistResponse; 4354 5045 type ResponseStream = T::StreamPlaylistStream; 4355 4355 - type Future = 4356 4356 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 5046 5046 + type Future = BoxFuture< 5047 5047 + tonic::Response<Self::ResponseStream>, 5048 5048 + tonic::Status, 5049 5049 + >; 4357 5050 fn call( 4358 5051 &mut self, 4359 5052 request: tonic::Request<super::StreamPlaylistRequest>, 4360 5053 ) -> Self::Future { 4361 5054 let inner = Arc::clone(&self.0); 4362 5055 let fut = async move { 4363 4363 - <T as PlaybackService>::stream_playlist(&inner, request).await 5056 5056 + <T as PlaybackService>::stream_playlist(&inner, request) 5057 5057 + .await 4364 5058 }; 4365 5059 Box::pin(fut) 4366 5060 } ··· 4387 5081 }; 4388 5082 Box::pin(fut) 4389 5083 } 4390 4390 - _ => Box::pin(async move { 4391 4391 - let mut response = http::Response::new(empty_body()); 4392 4392 - let headers = response.headers_mut(); 4393 4393 - headers.insert( 4394 4394 - tonic::Status::GRPC_STATUS, 4395 4395 - (tonic::Code::Unimplemented as i32).into(), 4396 4396 - ); 4397 4397 - headers.insert( 4398 4398 - http::header::CONTENT_TYPE, 4399 4399 - tonic::metadata::GRPC_CONTENT_TYPE, 4400 4400 - ); 4401 4401 - Ok(response) 4402 4402 - }), 5084 5084 + _ => { 5085 5085 + Box::pin(async move { 5086 5086 + let mut response = http::Response::new(empty_body()); 5087 5087 + let headers = response.headers_mut(); 5088 5088 + headers 5089 5089 + .insert( 5090 5090 + tonic::Status::GRPC_STATUS, 5091 5091 + (tonic::Code::Unimplemented as i32).into(), 5092 5092 + ); 5093 5093 + headers 5094 5094 + .insert( 5095 5095 + http::header::CONTENT_TYPE, 5096 5096 + tonic::metadata::GRPC_CONTENT_TYPE, 5097 5097 + ); 5098 5098 + Ok(response) 5099 5099 + }) 5100 5100 + } 4403 5101 } 4404 5102 } 4405 5103 } ··· 4606 5304 dead_code, 4607 5305 missing_docs, 4608 5306 clippy::wildcard_imports, 4609 4609 - clippy::let_unit_value 5307 5307 + clippy::let_unit_value, 4610 5308 )] 4611 4611 - use tonic::codegen::http::Uri; 4612 5309 use tonic::codegen::*; 5310 5310 + use tonic::codegen::http::Uri; 4613 5311 #[derive(Debug, Clone)] 4614 5312 pub struct PlaylistServiceClient<T> { 4615 5313 inner: tonic::client::Grpc<T>, ··· 4653 5351 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 4654 5352 >, 4655 5353 >, 4656 4656 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 4657 4657 - Into<StdError> + std::marker::Send + std::marker::Sync, 5354 5354 + <T as tonic::codegen::Service< 5355 5355 + http::Request<tonic::body::BoxBody>, 5356 5356 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 4658 5357 { 4659 5358 PlaylistServiceClient::new(InterceptedService::new(inner, interceptor)) 4660 5359 } ··· 4692 5391 pub async fn get_current( 4693 5392 &mut self, 4694 5393 request: impl tonic::IntoRequest<super::GetCurrentRequest>, 4695 4695 - ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status> 4696 4696 - { 4697 4697 - self.inner.ready().await.map_err(|e| { 4698 4698 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4699 4699 - })?; 5394 5394 + ) -> std::result::Result< 5395 5395 + tonic::Response<super::GetCurrentResponse>, 5396 5396 + tonic::Status, 5397 5397 + > { 5398 5398 + self.inner 5399 5399 + .ready() 5400 5400 + .await 5401 5401 + .map_err(|e| { 5402 5402 + tonic::Status::unknown( 5403 5403 + format!("Service was not ready: {}", e.into()), 5404 5404 + ) 5405 5405 + })?; 4700 5406 let codec = tonic::codec::ProstCodec::default(); 4701 5407 let path = http::uri::PathAndQuery::from_static( 4702 5408 "/rockbox.v1alpha1.PlaylistService/GetCurrent", 4703 5409 ); 4704 5410 let mut req = request.into_request(); 4705 4705 - req.extensions_mut().insert(GrpcMethod::new( 4706 4706 - "rockbox.v1alpha1.PlaylistService", 4707 4707 - "GetCurrent", 4708 4708 - )); 5411 5411 + req.extensions_mut() 5412 5412 + .insert( 5413 5413 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetCurrent"), 5414 5414 + ); 4709 5415 self.inner.unary(req, path, codec).await 4710 5416 } 4711 5417 pub async fn get_resume_info( 4712 5418 &mut self, 4713 5419 request: impl tonic::IntoRequest<super::GetResumeInfoRequest>, 4714 4714 - ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status> 4715 4715 - { 4716 4716 - self.inner.ready().await.map_err(|e| { 4717 4717 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4718 4718 - })?; 5420 5420 + ) -> std::result::Result< 5421 5421 + tonic::Response<super::GetResumeInfoResponse>, 5422 5422 + tonic::Status, 5423 5423 + > { 5424 5424 + self.inner 5425 5425 + .ready() 5426 5426 + .await 5427 5427 + .map_err(|e| { 5428 5428 + tonic::Status::unknown( 5429 5429 + format!("Service was not ready: {}", e.into()), 5430 5430 + ) 5431 5431 + })?; 4719 5432 let codec = tonic::codec::ProstCodec::default(); 4720 5433 let path = http::uri::PathAndQuery::from_static( 4721 5434 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo", 4722 5435 ); 4723 5436 let mut req = request.into_request(); 4724 4724 - req.extensions_mut().insert(GrpcMethod::new( 4725 4725 - "rockbox.v1alpha1.PlaylistService", 4726 4726 - "GetResumeInfo", 4727 4727 - )); 5437 5437 + req.extensions_mut() 5438 5438 + .insert( 5439 5439 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetResumeInfo"), 5440 5440 + ); 4728 5441 self.inner.unary(req, path, codec).await 4729 5442 } 4730 5443 pub async fn get_track_info( 4731 5444 &mut self, 4732 5445 request: impl tonic::IntoRequest<super::GetTrackInfoRequest>, 4733 4733 - ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status> 4734 4734 - { 4735 4735 - self.inner.ready().await.map_err(|e| { 4736 4736 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4737 4737 - })?; 5446 5446 + ) -> std::result::Result< 5447 5447 + tonic::Response<super::GetTrackInfoResponse>, 5448 5448 + tonic::Status, 5449 5449 + > { 5450 5450 + self.inner 5451 5451 + .ready() 5452 5452 + .await 5453 5453 + .map_err(|e| { 5454 5454 + tonic::Status::unknown( 5455 5455 + format!("Service was not ready: {}", e.into()), 5456 5456 + ) 5457 5457 + })?; 4738 5458 let codec = tonic::codec::ProstCodec::default(); 4739 5459 let path = http::uri::PathAndQuery::from_static( 4740 5460 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo", 4741 5461 ); 4742 5462 let mut req = request.into_request(); 4743 4743 - req.extensions_mut().insert(GrpcMethod::new( 4744 4744 - "rockbox.v1alpha1.PlaylistService", 4745 4745 - "GetTrackInfo", 4746 4746 - )); 5463 5463 + req.extensions_mut() 5464 5464 + .insert( 5465 5465 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetTrackInfo"), 5466 5466 + ); 4747 5467 self.inner.unary(req, path, codec).await 4748 5468 } 4749 5469 pub async fn get_first_index( 4750 5470 &mut self, 4751 5471 request: impl tonic::IntoRequest<super::GetFirstIndexRequest>, 4752 4752 - ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status> 4753 4753 - { 4754 4754 - self.inner.ready().await.map_err(|e| { 4755 4755 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4756 4756 - })?; 5472 5472 + ) -> std::result::Result< 5473 5473 + tonic::Response<super::GetFirstIndexResponse>, 5474 5474 + tonic::Status, 5475 5475 + > { 5476 5476 + self.inner 5477 5477 + .ready() 5478 5478 + .await 5479 5479 + .map_err(|e| { 5480 5480 + tonic::Status::unknown( 5481 5481 + format!("Service was not ready: {}", e.into()), 5482 5482 + ) 5483 5483 + })?; 4757 5484 let codec = tonic::codec::ProstCodec::default(); 4758 5485 let path = http::uri::PathAndQuery::from_static( 4759 5486 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex", 4760 5487 ); 4761 5488 let mut req = request.into_request(); 4762 4762 - req.extensions_mut().insert(GrpcMethod::new( 4763 4763 - "rockbox.v1alpha1.PlaylistService", 4764 4764 - "GetFirstIndex", 4765 4765 - )); 5489 5489 + req.extensions_mut() 5490 5490 + .insert( 5491 5491 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetFirstIndex"), 5492 5492 + ); 4766 5493 self.inner.unary(req, path, codec).await 4767 5494 } 4768 5495 pub async fn get_display_index( 4769 5496 &mut self, 4770 5497 request: impl tonic::IntoRequest<super::GetDisplayIndexRequest>, 4771 4771 - ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status> 4772 4772 - { 4773 4773 - self.inner.ready().await.map_err(|e| { 4774 4774 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4775 4775 - })?; 5498 5498 + ) -> std::result::Result< 5499 5499 + tonic::Response<super::GetDisplayIndexResponse>, 5500 5500 + tonic::Status, 5501 5501 + > { 5502 5502 + self.inner 5503 5503 + .ready() 5504 5504 + .await 5505 5505 + .map_err(|e| { 5506 5506 + tonic::Status::unknown( 5507 5507 + format!("Service was not ready: {}", e.into()), 5508 5508 + ) 5509 5509 + })?; 4776 5510 let codec = tonic::codec::ProstCodec::default(); 4777 5511 let path = http::uri::PathAndQuery::from_static( 4778 5512 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex", 4779 5513 ); 4780 5514 let mut req = request.into_request(); 4781 4781 - req.extensions_mut().insert(GrpcMethod::new( 4782 4782 - "rockbox.v1alpha1.PlaylistService", 4783 4783 - "GetDisplayIndex", 4784 4784 - )); 5515 5515 + req.extensions_mut() 5516 5516 + .insert( 5517 5517 + GrpcMethod::new( 5518 5518 + "rockbox.v1alpha1.PlaylistService", 5519 5519 + "GetDisplayIndex", 5520 5520 + ), 5521 5521 + ); 4785 5522 self.inner.unary(req, path, codec).await 4786 5523 } 4787 5524 pub async fn amount( 4788 5525 &mut self, 4789 5526 request: impl tonic::IntoRequest<super::AmountRequest>, 4790 5527 ) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status> { 4791 4791 - self.inner.ready().await.map_err(|e| { 4792 4792 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4793 4793 - })?; 5528 5528 + self.inner 5529 5529 + .ready() 5530 5530 + .await 5531 5531 + .map_err(|e| { 5532 5532 + tonic::Status::unknown( 5533 5533 + format!("Service was not ready: {}", e.into()), 5534 5534 + ) 5535 5535 + })?; 4794 5536 let codec = tonic::codec::ProstCodec::default(); 4795 4795 - let path = 4796 4796 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Amount"); 5537 5537 + let path = http::uri::PathAndQuery::from_static( 5538 5538 + "/rockbox.v1alpha1.PlaylistService/Amount", 5539 5539 + ); 4797 5540 let mut req = request.into_request(); 4798 4798 - req.extensions_mut().insert(GrpcMethod::new( 4799 4799 - "rockbox.v1alpha1.PlaylistService", 4800 4800 - "Amount", 4801 4801 - )); 5541 5541 + req.extensions_mut() 5542 5542 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Amount")); 4802 5543 self.inner.unary(req, path, codec).await 4803 5544 } 4804 5545 pub async fn playlist_resume( 4805 5546 &mut self, 4806 5547 request: impl tonic::IntoRequest<super::PlaylistResumeRequest>, 4807 4807 - ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status> 4808 4808 - { 4809 4809 - self.inner.ready().await.map_err(|e| { 4810 4810 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4811 4811 - })?; 5548 5548 + ) -> std::result::Result< 5549 5549 + tonic::Response<super::PlaylistResumeResponse>, 5550 5550 + tonic::Status, 5551 5551 + > { 5552 5552 + self.inner 5553 5553 + .ready() 5554 5554 + .await 5555 5555 + .map_err(|e| { 5556 5556 + tonic::Status::unknown( 5557 5557 + format!("Service was not ready: {}", e.into()), 5558 5558 + ) 5559 5559 + })?; 4812 5560 let codec = tonic::codec::ProstCodec::default(); 4813 5561 let path = http::uri::PathAndQuery::from_static( 4814 5562 "/rockbox.v1alpha1.PlaylistService/PlaylistResume", 4815 5563 ); 4816 5564 let mut req = request.into_request(); 4817 4817 - req.extensions_mut().insert(GrpcMethod::new( 4818 4818 - "rockbox.v1alpha1.PlaylistService", 4819 4819 - "PlaylistResume", 4820 4820 - )); 5565 5565 + req.extensions_mut() 5566 5566 + .insert( 5567 5567 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "PlaylistResume"), 5568 5568 + ); 4821 5569 self.inner.unary(req, path, codec).await 4822 5570 } 4823 5571 pub async fn resume_track( 4824 5572 &mut self, 4825 5573 request: impl tonic::IntoRequest<super::ResumeTrackRequest>, 4826 4826 - ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status> 4827 4827 - { 4828 4828 - self.inner.ready().await.map_err(|e| { 4829 4829 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4830 4830 - })?; 5574 5574 + ) -> std::result::Result< 5575 5575 + tonic::Response<super::ResumeTrackResponse>, 5576 5576 + tonic::Status, 5577 5577 + > { 5578 5578 + self.inner 5579 5579 + .ready() 5580 5580 + .await 5581 5581 + .map_err(|e| { 5582 5582 + tonic::Status::unknown( 5583 5583 + format!("Service was not ready: {}", e.into()), 5584 5584 + ) 5585 5585 + })?; 4831 5586 let codec = tonic::codec::ProstCodec::default(); 4832 5587 let path = http::uri::PathAndQuery::from_static( 4833 5588 "/rockbox.v1alpha1.PlaylistService/ResumeTrack", 4834 5589 ); 4835 5590 let mut req = request.into_request(); 4836 4836 - req.extensions_mut().insert(GrpcMethod::new( 4837 4837 - "rockbox.v1alpha1.PlaylistService", 4838 4838 - "ResumeTrack", 4839 4839 - )); 5591 5591 + req.extensions_mut() 5592 5592 + .insert( 5593 5593 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "ResumeTrack"), 5594 5594 + ); 4840 5595 self.inner.unary(req, path, codec).await 4841 5596 } 4842 5597 pub async fn set_modified( 4843 5598 &mut self, 4844 5599 request: impl tonic::IntoRequest<super::SetModifiedRequest>, 4845 4845 - ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status> 4846 4846 - { 4847 4847 - self.inner.ready().await.map_err(|e| { 4848 4848 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4849 4849 - })?; 5600 5600 + ) -> std::result::Result< 5601 5601 + tonic::Response<super::SetModifiedResponse>, 5602 5602 + tonic::Status, 5603 5603 + > { 5604 5604 + self.inner 5605 5605 + .ready() 5606 5606 + .await 5607 5607 + .map_err(|e| { 5608 5608 + tonic::Status::unknown( 5609 5609 + format!("Service was not ready: {}", e.into()), 5610 5610 + ) 5611 5611 + })?; 4850 5612 let codec = tonic::codec::ProstCodec::default(); 4851 5613 let path = http::uri::PathAndQuery::from_static( 4852 5614 "/rockbox.v1alpha1.PlaylistService/SetModified", 4853 5615 ); 4854 5616 let mut req = request.into_request(); 4855 4855 - req.extensions_mut().insert(GrpcMethod::new( 4856 4856 - "rockbox.v1alpha1.PlaylistService", 4857 4857 - "SetModified", 4858 4858 - )); 5617 5617 + req.extensions_mut() 5618 5618 + .insert( 5619 5619 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "SetModified"), 5620 5620 + ); 4859 5621 self.inner.unary(req, path, codec).await 4860 5622 } 4861 5623 pub async fn start( 4862 5624 &mut self, 4863 5625 request: impl tonic::IntoRequest<super::StartRequest>, 4864 5626 ) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status> { 4865 4865 - self.inner.ready().await.map_err(|e| { 4866 4866 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4867 4867 - })?; 5627 5627 + self.inner 5628 5628 + .ready() 5629 5629 + .await 5630 5630 + .map_err(|e| { 5631 5631 + tonic::Status::unknown( 5632 5632 + format!("Service was not ready: {}", e.into()), 5633 5633 + ) 5634 5634 + })?; 4868 5635 let codec = tonic::codec::ProstCodec::default(); 4869 4869 - let path = 4870 4870 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Start"); 5636 5636 + let path = http::uri::PathAndQuery::from_static( 5637 5637 + "/rockbox.v1alpha1.PlaylistService/Start", 5638 5638 + ); 4871 5639 let mut req = request.into_request(); 4872 5640 req.extensions_mut() 4873 5641 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Start")); ··· 4877 5645 &mut self, 4878 5646 request: impl tonic::IntoRequest<super::SyncRequest>, 4879 5647 ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> { 4880 4880 - self.inner.ready().await.map_err(|e| { 4881 4881 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4882 4882 - })?; 5648 5648 + self.inner 5649 5649 + .ready() 5650 5650 + .await 5651 5651 + .map_err(|e| { 5652 5652 + tonic::Status::unknown( 5653 5653 + format!("Service was not ready: {}", e.into()), 5654 5654 + ) 5655 5655 + })?; 4883 5656 let codec = tonic::codec::ProstCodec::default(); 4884 4884 - let path = 4885 4885 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Sync"); 5657 5657 + let path = http::uri::PathAndQuery::from_static( 5658 5658 + "/rockbox.v1alpha1.PlaylistService/Sync", 5659 5659 + ); 4886 5660 let mut req = request.into_request(); 4887 5661 req.extensions_mut() 4888 5662 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Sync")); ··· 4891 5665 pub async fn remove_all_tracks( 4892 5666 &mut self, 4893 5667 request: impl tonic::IntoRequest<super::RemoveAllTracksRequest>, 4894 4894 - ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status> 4895 4895 - { 4896 4896 - self.inner.ready().await.map_err(|e| { 4897 4897 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4898 4898 - })?; 5668 5668 + ) -> std::result::Result< 5669 5669 + tonic::Response<super::RemoveAllTracksResponse>, 5670 5670 + tonic::Status, 5671 5671 + > { 5672 5672 + self.inner 5673 5673 + .ready() 5674 5674 + .await 5675 5675 + .map_err(|e| { 5676 5676 + tonic::Status::unknown( 5677 5677 + format!("Service was not ready: {}", e.into()), 5678 5678 + ) 5679 5679 + })?; 4899 5680 let codec = tonic::codec::ProstCodec::default(); 4900 5681 let path = http::uri::PathAndQuery::from_static( 4901 5682 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks", 4902 5683 ); 4903 5684 let mut req = request.into_request(); 4904 4904 - req.extensions_mut().insert(GrpcMethod::new( 4905 4905 - "rockbox.v1alpha1.PlaylistService", 4906 4906 - "RemoveAllTracks", 4907 4907 - )); 5685 5685 + req.extensions_mut() 5686 5686 + .insert( 5687 5687 + GrpcMethod::new( 5688 5688 + "rockbox.v1alpha1.PlaylistService", 5689 5689 + "RemoveAllTracks", 5690 5690 + ), 5691 5691 + ); 4908 5692 self.inner.unary(req, path, codec).await 4909 5693 } 4910 5694 pub async fn remove_tracks( 4911 5695 &mut self, 4912 5696 request: impl tonic::IntoRequest<super::RemoveTracksRequest>, 4913 4913 - ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status> 4914 4914 - { 4915 4915 - self.inner.ready().await.map_err(|e| { 4916 4916 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4917 4917 - })?; 5697 5697 + ) -> std::result::Result< 5698 5698 + tonic::Response<super::RemoveTracksResponse>, 5699 5699 + tonic::Status, 5700 5700 + > { 5701 5701 + self.inner 5702 5702 + .ready() 5703 5703 + .await 5704 5704 + .map_err(|e| { 5705 5705 + tonic::Status::unknown( 5706 5706 + format!("Service was not ready: {}", e.into()), 5707 5707 + ) 5708 5708 + })?; 4918 5709 let codec = tonic::codec::ProstCodec::default(); 4919 5710 let path = http::uri::PathAndQuery::from_static( 4920 5711 "/rockbox.v1alpha1.PlaylistService/RemoveTracks", 4921 5712 ); 4922 5713 let mut req = request.into_request(); 4923 4923 - req.extensions_mut().insert(GrpcMethod::new( 4924 4924 - "rockbox.v1alpha1.PlaylistService", 4925 4925 - "RemoveTracks", 4926 4926 - )); 5714 5714 + req.extensions_mut() 5715 5715 + .insert( 5716 5716 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "RemoveTracks"), 5717 5717 + ); 4927 5718 self.inner.unary(req, path, codec).await 4928 5719 } 4929 5720 pub async fn create_playlist( 4930 5721 &mut self, 4931 5722 request: impl tonic::IntoRequest<super::CreatePlaylistRequest>, 4932 4932 - ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status> 4933 4933 - { 4934 4934 - self.inner.ready().await.map_err(|e| { 4935 4935 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4936 4936 - })?; 5723 5723 + ) -> std::result::Result< 5724 5724 + tonic::Response<super::CreatePlaylistResponse>, 5725 5725 + tonic::Status, 5726 5726 + > { 5727 5727 + self.inner 5728 5728 + .ready() 5729 5729 + .await 5730 5730 + .map_err(|e| { 5731 5731 + tonic::Status::unknown( 5732 5732 + format!("Service was not ready: {}", e.into()), 5733 5733 + ) 5734 5734 + })?; 4937 5735 let codec = tonic::codec::ProstCodec::default(); 4938 5736 let path = http::uri::PathAndQuery::from_static( 4939 5737 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist", 4940 5738 ); 4941 5739 let mut req = request.into_request(); 4942 4942 - req.extensions_mut().insert(GrpcMethod::new( 4943 4943 - "rockbox.v1alpha1.PlaylistService", 4944 4944 - "CreatePlaylist", 4945 4945 - )); 5740 5740 + req.extensions_mut() 5741 5741 + .insert( 5742 5742 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "CreatePlaylist"), 5743 5743 + ); 4946 5744 self.inner.unary(req, path, codec).await 4947 5745 } 4948 5746 pub async fn insert_tracks( 4949 5747 &mut self, 4950 5748 request: impl tonic::IntoRequest<super::InsertTracksRequest>, 4951 4951 - ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status> 4952 4952 - { 4953 4953 - self.inner.ready().await.map_err(|e| { 4954 4954 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4955 4955 - })?; 5749 5749 + ) -> std::result::Result< 5750 5750 + tonic::Response<super::InsertTracksResponse>, 5751 5751 + tonic::Status, 5752 5752 + > { 5753 5753 + self.inner 5754 5754 + .ready() 5755 5755 + .await 5756 5756 + .map_err(|e| { 5757 5757 + tonic::Status::unknown( 5758 5758 + format!("Service was not ready: {}", e.into()), 5759 5759 + ) 5760 5760 + })?; 4956 5761 let codec = tonic::codec::ProstCodec::default(); 4957 5762 let path = http::uri::PathAndQuery::from_static( 4958 5763 "/rockbox.v1alpha1.PlaylistService/InsertTracks", 4959 5764 ); 4960 5765 let mut req = request.into_request(); 4961 4961 - req.extensions_mut().insert(GrpcMethod::new( 4962 4962 - "rockbox.v1alpha1.PlaylistService", 4963 4963 - "InsertTracks", 4964 4964 - )); 5766 5766 + req.extensions_mut() 5767 5767 + .insert( 5768 5768 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertTracks"), 5769 5769 + ); 4965 5770 self.inner.unary(req, path, codec).await 4966 5771 } 4967 5772 pub async fn insert_directory( 4968 5773 &mut self, 4969 5774 request: impl tonic::IntoRequest<super::InsertDirectoryRequest>, 4970 4970 - ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status> 4971 4971 - { 4972 4972 - self.inner.ready().await.map_err(|e| { 4973 4973 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4974 4974 - })?; 5775 5775 + ) -> std::result::Result< 5776 5776 + tonic::Response<super::InsertDirectoryResponse>, 5777 5777 + tonic::Status, 5778 5778 + > { 5779 5779 + self.inner 5780 5780 + .ready() 5781 5781 + .await 5782 5782 + .map_err(|e| { 5783 5783 + tonic::Status::unknown( 5784 5784 + format!("Service was not ready: {}", e.into()), 5785 5785 + ) 5786 5786 + })?; 4975 5787 let codec = tonic::codec::ProstCodec::default(); 4976 5788 let path = http::uri::PathAndQuery::from_static( 4977 5789 "/rockbox.v1alpha1.PlaylistService/InsertDirectory", 4978 5790 ); 4979 5791 let mut req = request.into_request(); 4980 4980 - req.extensions_mut().insert(GrpcMethod::new( 4981 4981 - "rockbox.v1alpha1.PlaylistService", 4982 4982 - "InsertDirectory", 4983 4983 - )); 5792 5792 + req.extensions_mut() 5793 5793 + .insert( 5794 5794 + GrpcMethod::new( 5795 5795 + "rockbox.v1alpha1.PlaylistService", 5796 5796 + "InsertDirectory", 5797 5797 + ), 5798 5798 + ); 4984 5799 self.inner.unary(req, path, codec).await 4985 5800 } 4986 5801 pub async fn insert_playlist( 4987 5802 &mut self, 4988 5803 request: impl tonic::IntoRequest<super::InsertPlaylistRequest>, 4989 4989 - ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status> 4990 4990 - { 4991 4991 - self.inner.ready().await.map_err(|e| { 4992 4992 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4993 4993 - })?; 5804 5804 + ) -> std::result::Result< 5805 5805 + tonic::Response<super::InsertPlaylistResponse>, 5806 5806 + tonic::Status, 5807 5807 + > { 5808 5808 + self.inner 5809 5809 + .ready() 5810 5810 + .await 5811 5811 + .map_err(|e| { 5812 5812 + tonic::Status::unknown( 5813 5813 + format!("Service was not ready: {}", e.into()), 5814 5814 + ) 5815 5815 + })?; 4994 5816 let codec = tonic::codec::ProstCodec::default(); 4995 5817 let path = http::uri::PathAndQuery::from_static( 4996 5818 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist", 4997 5819 ); 4998 5820 let mut req = request.into_request(); 4999 4999 - req.extensions_mut().insert(GrpcMethod::new( 5000 5000 - "rockbox.v1alpha1.PlaylistService", 5001 5001 - "InsertPlaylist", 5002 5002 - )); 5821 5821 + req.extensions_mut() 5822 5822 + .insert( 5823 5823 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertPlaylist"), 5824 5824 + ); 5003 5825 self.inner.unary(req, path, codec).await 5004 5826 } 5005 5827 pub async fn insert_album( 5006 5828 &mut self, 5007 5829 request: impl tonic::IntoRequest<super::InsertAlbumRequest>, 5008 5008 - ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status> 5009 5009 - { 5010 5010 - self.inner.ready().await.map_err(|e| { 5011 5011 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 5012 5012 - })?; 5830 5830 + ) -> std::result::Result< 5831 5831 + tonic::Response<super::InsertAlbumResponse>, 5832 5832 + tonic::Status, 5833 5833 + > { 5834 5834 + self.inner 5835 5835 + .ready() 5836 5836 + .await 5837 5837 + .map_err(|e| { 5838 5838 + tonic::Status::unknown( 5839 5839 + format!("Service was not ready: {}", e.into()), 5840 5840 + ) 5841 5841 + })?; 5013 5842 let codec = tonic::codec::ProstCodec::default(); 5014 5843 let path = http::uri::PathAndQuery::from_static( 5015 5844 "/rockbox.v1alpha1.PlaylistService/InsertAlbum", 5016 5845 ); 5017 5846 let mut req = request.into_request(); 5018 5018 - req.extensions_mut().insert(GrpcMethod::new( 5019 5019 - "rockbox.v1alpha1.PlaylistService", 5020 5020 - "InsertAlbum", 5021 5021 - )); 5847 5847 + req.extensions_mut() 5848 5848 + .insert( 5849 5849 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertAlbum"), 5850 5850 + ); 5022 5851 self.inner.unary(req, path, codec).await 5023 5852 } 5024 5853 pub async fn insert_artist_tracks( 5025 5854 &mut self, 5026 5855 request: impl tonic::IntoRequest<super::InsertArtistTracksRequest>, 5027 5027 - ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status> 5028 5028 - { 5029 5029 - self.inner.ready().await.map_err(|e| { 5030 5030 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 5031 5031 - })?; 5856 5856 + ) -> std::result::Result< 5857 5857 + tonic::Response<super::InsertArtistTracksResponse>, 5858 5858 + tonic::Status, 5859 5859 + > { 5860 5860 + self.inner 5861 5861 + .ready() 5862 5862 + .await 5863 5863 + .map_err(|e| { 5864 5864 + tonic::Status::unknown( 5865 5865 + format!("Service was not ready: {}", e.into()), 5866 5866 + ) 5867 5867 + })?; 5032 5868 let codec = tonic::codec::ProstCodec::default(); 5033 5869 let path = http::uri::PathAndQuery::from_static( 5034 5870 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks", 5035 5871 ); 5036 5872 let mut req = request.into_request(); 5037 5037 - req.extensions_mut().insert(GrpcMethod::new( 5038 5038 - "rockbox.v1alpha1.PlaylistService", 5039 5039 - "InsertArtistTracks", 5040 5040 - )); 5873 5873 + req.extensions_mut() 5874 5874 + .insert( 5875 5875 + GrpcMethod::new( 5876 5876 + "rockbox.v1alpha1.PlaylistService", 5877 5877 + "InsertArtistTracks", 5878 5878 + ), 5879 5879 + ); 5041 5880 self.inner.unary(req, path, codec).await 5042 5881 } 5043 5882 pub async fn shuffle_playlist( 5044 5883 &mut self, 5045 5884 request: impl tonic::IntoRequest<super::ShufflePlaylistRequest>, 5046 5046 - ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status> 5047 5047 - { 5048 5048 - self.inner.ready().await.map_err(|e| { 5049 5049 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 5050 5050 - })?; 5885 5885 + ) -> std::result::Result< 5886 5886 + tonic::Response<super::ShufflePlaylistResponse>, 5887 5887 + tonic::Status, 5888 5888 + > { 5889 5889 + self.inner 5890 5890 + .ready() 5891 5891 + .await 5892 5892 + .map_err(|e| { 5893 5893 + tonic::Status::unknown( 5894 5894 + format!("Service was not ready: {}", e.into()), 5895 5895 + ) 5896 5896 + })?; 5051 5897 let codec = tonic::codec::ProstCodec::default(); 5052 5898 let path = http::uri::PathAndQuery::from_static( 5053 5899 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist", 5054 5900 ); 5055 5901 let mut req = request.into_request(); 5056 5056 - req.extensions_mut().insert(GrpcMethod::new( 5057 5057 - "rockbox.v1alpha1.PlaylistService", 5058 5058 - "ShufflePlaylist", 5059 5059 - )); 5902 5902 + req.extensions_mut() 5903 5903 + .insert( 5904 5904 + GrpcMethod::new( 5905 5905 + "rockbox.v1alpha1.PlaylistService", 5906 5906 + "ShufflePlaylist", 5907 5907 + ), 5908 5908 + ); 5060 5909 self.inner.unary(req, path, codec).await 5061 5910 } 5062 5911 } ··· 5068 5917 dead_code, 5069 5918 missing_docs, 5070 5919 clippy::wildcard_imports, 5071 5071 - clippy::let_unit_value 5920 5920 + clippy::let_unit_value, 5072 5921 )] 5073 5922 use tonic::codegen::*; 5074 5923 /// Generated trait containing gRPC methods that should be implemented for use with PlaylistServiceServer. ··· 5077 5926 async fn get_current( 5078 5927 &self, 5079 5928 request: tonic::Request<super::GetCurrentRequest>, 5080 5080 - ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status>; 5929 5929 + ) -> std::result::Result< 5930 5930 + tonic::Response<super::GetCurrentResponse>, 5931 5931 + tonic::Status, 5932 5932 + >; 5081 5933 async fn get_resume_info( 5082 5934 &self, 5083 5935 request: tonic::Request<super::GetResumeInfoRequest>, 5084 5084 - ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status>; 5936 5936 + ) -> std::result::Result< 5937 5937 + tonic::Response<super::GetResumeInfoResponse>, 5938 5938 + tonic::Status, 5939 5939 + >; 5085 5940 async fn get_track_info( 5086 5941 &self, 5087 5942 request: tonic::Request<super::GetTrackInfoRequest>, 5088 5088 - ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status>; 5943 5943 + ) -> std::result::Result< 5944 5944 + tonic::Response<super::GetTrackInfoResponse>, 5945 5945 + tonic::Status, 5946 5946 + >; 5089 5947 async fn get_first_index( 5090 5948 &self, 5091 5949 request: tonic::Request<super::GetFirstIndexRequest>, 5092 5092 - ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status>; 5950 5950 + ) -> std::result::Result< 5951 5951 + tonic::Response<super::GetFirstIndexResponse>, 5952 5952 + tonic::Status, 5953 5953 + >; 5093 5954 async fn get_display_index( 5094 5955 &self, 5095 5956 request: tonic::Request<super::GetDisplayIndexRequest>, 5096 5096 - ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>; 5957 5957 + ) -> std::result::Result< 5958 5958 + tonic::Response<super::GetDisplayIndexResponse>, 5959 5959 + tonic::Status, 5960 5960 + >; 5097 5961 async fn amount( 5098 5962 &self, 5099 5963 request: tonic::Request<super::AmountRequest>, ··· 5101 5965 async fn playlist_resume( 5102 5966 &self, 5103 5967 request: tonic::Request<super::PlaylistResumeRequest>, 5104 5104 - ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status>; 5968 5968 + ) -> std::result::Result< 5969 5969 + tonic::Response<super::PlaylistResumeResponse>, 5970 5970 + tonic::Status, 5971 5971 + >; 5105 5972 async fn resume_track( 5106 5973 &self, 5107 5974 request: tonic::Request<super::ResumeTrackRequest>, 5108 5108 - ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status>; 5975 5975 + ) -> std::result::Result< 5976 5976 + tonic::Response<super::ResumeTrackResponse>, 5977 5977 + tonic::Status, 5978 5978 + >; 5109 5979 async fn set_modified( 5110 5980 &self, 5111 5981 request: tonic::Request<super::SetModifiedRequest>, 5112 5112 - ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>; 5982 5982 + ) -> std::result::Result< 5983 5983 + tonic::Response<super::SetModifiedResponse>, 5984 5984 + tonic::Status, 5985 5985 + >; 5113 5986 async fn start( 5114 5987 &self, 5115 5988 request: tonic::Request<super::StartRequest>, ··· 5121 5994 async fn remove_all_tracks( 5122 5995 &self, 5123 5996 request: tonic::Request<super::RemoveAllTracksRequest>, 5124 5124 - ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status>; 5997 5997 + ) -> std::result::Result< 5998 5998 + tonic::Response<super::RemoveAllTracksResponse>, 5999 5999 + tonic::Status, 6000 6000 + >; 5125 6001 async fn remove_tracks( 5126 6002 &self, 5127 6003 request: tonic::Request<super::RemoveTracksRequest>, 5128 5128 - ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status>; 6004 6004 + ) -> std::result::Result< 6005 6005 + tonic::Response<super::RemoveTracksResponse>, 6006 6006 + tonic::Status, 6007 6007 + >; 5129 6008 async fn create_playlist( 5130 6009 &self, 5131 6010 request: tonic::Request<super::CreatePlaylistRequest>, 5132 5132 - ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status>; 6011 6011 + ) -> std::result::Result< 6012 6012 + tonic::Response<super::CreatePlaylistResponse>, 6013 6013 + tonic::Status, 6014 6014 + >; 5133 6015 async fn insert_tracks( 5134 6016 &self, 5135 6017 request: tonic::Request<super::InsertTracksRequest>, 5136 5136 - ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status>; 6018 6018 + ) -> std::result::Result< 6019 6019 + tonic::Response<super::InsertTracksResponse>, 6020 6020 + tonic::Status, 6021 6021 + >; 5137 6022 async fn insert_directory( 5138 6023 &self, 5139 6024 request: tonic::Request<super::InsertDirectoryRequest>, 5140 5140 - ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status>; 6025 6025 + ) -> std::result::Result< 6026 6026 + tonic::Response<super::InsertDirectoryResponse>, 6027 6027 + tonic::Status, 6028 6028 + >; 5141 6029 async fn insert_playlist( 5142 6030 &self, 5143 6031 request: tonic::Request<super::InsertPlaylistRequest>, 5144 5144 - ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status>; 6032 6032 + ) -> std::result::Result< 6033 6033 + tonic::Response<super::InsertPlaylistResponse>, 6034 6034 + tonic::Status, 6035 6035 + >; 5145 6036 async fn insert_album( 5146 6037 &self, 5147 6038 request: tonic::Request<super::InsertAlbumRequest>, 5148 5148 - ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>; 6039 6039 + ) -> std::result::Result< 6040 6040 + tonic::Response<super::InsertAlbumResponse>, 6041 6041 + tonic::Status, 6042 6042 + >; 5149 6043 async fn insert_artist_tracks( 5150 6044 &self, 5151 6045 request: tonic::Request<super::InsertArtistTracksRequest>, 5152 5152 - ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>; 6046 6046 + ) -> std::result::Result< 6047 6047 + tonic::Response<super::InsertArtistTracksResponse>, 6048 6048 + tonic::Status, 6049 6049 + >; 5153 6050 async fn shuffle_playlist( 5154 6051 &self, 5155 6052 request: tonic::Request<super::ShufflePlaylistRequest>, 5156 5156 - ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>; 6053 6053 + ) -> std::result::Result< 6054 6054 + tonic::Response<super::ShufflePlaylistResponse>, 6055 6055 + tonic::Status, 6056 6056 + >; 5157 6057 } 5158 6058 #[derive(Debug)] 5159 6059 pub struct PlaylistServiceServer<T> { ··· 5176 6076 max_encoding_message_size: None, 5177 6077 } 5178 6078 } 5179 5179 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 6079 6079 + pub fn with_interceptor<F>( 6080 6080 + inner: T, 6081 6081 + interceptor: F, 6082 6082 + ) -> InterceptedService<Self, F> 5180 6083 where 5181 6084 F: tonic::service::Interceptor, 5182 6085 { ··· 5231 6134 "/rockbox.v1alpha1.PlaylistService/GetCurrent" => { 5232 6135 #[allow(non_camel_case_types)] 5233 6136 struct GetCurrentSvc<T: PlaylistService>(pub Arc<T>); 5234 5234 - impl<T: PlaylistService> tonic::server::UnaryService<super::GetCurrentRequest> 5235 5235 - for GetCurrentSvc<T> 5236 5236 - { 6137 6137 + impl< 6138 6138 + T: PlaylistService, 6139 6139 + > tonic::server::UnaryService<super::GetCurrentRequest> 6140 6140 + for GetCurrentSvc<T> { 5237 6141 type Response = super::GetCurrentResponse; 5238 5238 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6142 6142 + type Future = BoxFuture< 6143 6143 + tonic::Response<Self::Response>, 6144 6144 + tonic::Status, 6145 6145 + >; 5239 6146 fn call( 5240 6147 &mut self, 5241 6148 request: tonic::Request<super::GetCurrentRequest>, ··· 5272 6179 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo" => { 5273 6180 #[allow(non_camel_case_types)] 5274 6181 struct GetResumeInfoSvc<T: PlaylistService>(pub Arc<T>); 5275 5275 - impl<T: PlaylistService> 5276 5276 - tonic::server::UnaryService<super::GetResumeInfoRequest> 5277 5277 - for GetResumeInfoSvc<T> 5278 5278 - { 6182 6182 + impl< 6183 6183 + T: PlaylistService, 6184 6184 + > tonic::server::UnaryService<super::GetResumeInfoRequest> 6185 6185 + for GetResumeInfoSvc<T> { 5279 6186 type Response = super::GetResumeInfoResponse; 5280 5280 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6187 6187 + type Future = BoxFuture< 6188 6188 + tonic::Response<Self::Response>, 6189 6189 + tonic::Status, 6190 6190 + >; 5281 6191 fn call( 5282 6192 &mut self, 5283 6193 request: tonic::Request<super::GetResumeInfoRequest>, 5284 6194 ) -> Self::Future { 5285 6195 let inner = Arc::clone(&self.0); 5286 6196 let fut = async move { 5287 5287 - <T as PlaylistService>::get_resume_info(&inner, request).await 6197 6197 + <T as PlaylistService>::get_resume_info(&inner, request) 6198 6198 + .await 5288 6199 }; 5289 6200 Box::pin(fut) 5290 6201 } ··· 5314 6225 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo" => { 5315 6226 #[allow(non_camel_case_types)] 5316 6227 struct GetTrackInfoSvc<T: PlaylistService>(pub Arc<T>); 5317 5317 - impl<T: PlaylistService> tonic::server::UnaryService<super::GetTrackInfoRequest> 5318 5318 - for GetTrackInfoSvc<T> 5319 5319 - { 6228 6228 + impl< 6229 6229 + T: PlaylistService, 6230 6230 + > tonic::server::UnaryService<super::GetTrackInfoRequest> 6231 6231 + for GetTrackInfoSvc<T> { 5320 6232 type Response = super::GetTrackInfoResponse; 5321 5321 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6233 6233 + type Future = BoxFuture< 6234 6234 + tonic::Response<Self::Response>, 6235 6235 + tonic::Status, 6236 6236 + >; 5322 6237 fn call( 5323 6238 &mut self, 5324 6239 request: tonic::Request<super::GetTrackInfoRequest>, 5325 6240 ) -> Self::Future { 5326 6241 let inner = Arc::clone(&self.0); 5327 6242 let fut = async move { 5328 5328 - <T as PlaylistService>::get_track_info(&inner, request).await 6243 6243 + <T as PlaylistService>::get_track_info(&inner, request) 6244 6244 + .await 5329 6245 }; 5330 6246 Box::pin(fut) 5331 6247 } ··· 5355 6271 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex" => { 5356 6272 #[allow(non_camel_case_types)] 5357 6273 struct GetFirstIndexSvc<T: PlaylistService>(pub Arc<T>); 5358 5358 - impl<T: PlaylistService> 5359 5359 - tonic::server::UnaryService<super::GetFirstIndexRequest> 5360 5360 - for GetFirstIndexSvc<T> 5361 5361 - { 6274 6274 + impl< 6275 6275 + T: PlaylistService, 6276 6276 + > tonic::server::UnaryService<super::GetFirstIndexRequest> 6277 6277 + for GetFirstIndexSvc<T> { 5362 6278 type Response = super::GetFirstIndexResponse; 5363 5363 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6279 6279 + type Future = BoxFuture< 6280 6280 + tonic::Response<Self::Response>, 6281 6281 + tonic::Status, 6282 6282 + >; 5364 6283 fn call( 5365 6284 &mut self, 5366 6285 request: tonic::Request<super::GetFirstIndexRequest>, 5367 6286 ) -> Self::Future { 5368 6287 let inner = Arc::clone(&self.0); 5369 6288 let fut = async move { 5370 5370 - <T as PlaylistService>::get_first_index(&inner, request).await 6289 6289 + <T as PlaylistService>::get_first_index(&inner, request) 6290 6290 + .await 5371 6291 }; 5372 6292 Box::pin(fut) 5373 6293 } ··· 5397 6317 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex" => { 5398 6318 #[allow(non_camel_case_types)] 5399 6319 struct GetDisplayIndexSvc<T: PlaylistService>(pub Arc<T>); 5400 5400 - impl<T: PlaylistService> 5401 5401 - tonic::server::UnaryService<super::GetDisplayIndexRequest> 5402 5402 - for GetDisplayIndexSvc<T> 5403 5403 - { 6320 6320 + impl< 6321 6321 + T: PlaylistService, 6322 6322 + > tonic::server::UnaryService<super::GetDisplayIndexRequest> 6323 6323 + for GetDisplayIndexSvc<T> { 5404 6324 type Response = super::GetDisplayIndexResponse; 5405 5405 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6325 6325 + type Future = BoxFuture< 6326 6326 + tonic::Response<Self::Response>, 6327 6327 + tonic::Status, 6328 6328 + >; 5406 6329 fn call( 5407 6330 &mut self, 5408 6331 request: tonic::Request<super::GetDisplayIndexRequest>, 5409 6332 ) -> Self::Future { 5410 6333 let inner = Arc::clone(&self.0); 5411 6334 let fut = async move { 5412 5412 - <T as PlaylistService>::get_display_index(&inner, request).await 6335 6335 + <T as PlaylistService>::get_display_index(&inner, request) 6336 6336 + .await 5413 6337 }; 5414 6338 Box::pin(fut) 5415 6339 } ··· 5439 6363 "/rockbox.v1alpha1.PlaylistService/Amount" => { 5440 6364 #[allow(non_camel_case_types)] 5441 6365 struct AmountSvc<T: PlaylistService>(pub Arc<T>); 5442 5442 - impl<T: PlaylistService> tonic::server::UnaryService<super::AmountRequest> for AmountSvc<T> { 6366 6366 + impl< 6367 6367 + T: PlaylistService, 6368 6368 + > tonic::server::UnaryService<super::AmountRequest> 6369 6369 + for AmountSvc<T> { 5443 6370 type Response = super::AmountResponse; 5444 5444 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6371 6371 + type Future = BoxFuture< 6372 6372 + tonic::Response<Self::Response>, 6373 6373 + tonic::Status, 6374 6374 + >; 5445 6375 fn call( 5446 6376 &mut self, 5447 6377 request: tonic::Request<super::AmountRequest>, ··· 5478 6408 "/rockbox.v1alpha1.PlaylistService/PlaylistResume" => { 5479 6409 #[allow(non_camel_case_types)] 5480 6410 struct PlaylistResumeSvc<T: PlaylistService>(pub Arc<T>); 5481 5481 - impl<T: PlaylistService> 5482 5482 - tonic::server::UnaryService<super::PlaylistResumeRequest> 5483 5483 - for PlaylistResumeSvc<T> 5484 5484 - { 6411 6411 + impl< 6412 6412 + T: PlaylistService, 6413 6413 + > tonic::server::UnaryService<super::PlaylistResumeRequest> 6414 6414 + for PlaylistResumeSvc<T> { 5485 6415 type Response = super::PlaylistResumeResponse; 5486 5486 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6416 6416 + type Future = BoxFuture< 6417 6417 + tonic::Response<Self::Response>, 6418 6418 + tonic::Status, 6419 6419 + >; 5487 6420 fn call( 5488 6421 &mut self, 5489 6422 request: tonic::Request<super::PlaylistResumeRequest>, 5490 6423 ) -> Self::Future { 5491 6424 let inner = Arc::clone(&self.0); 5492 6425 let fut = async move { 5493 5493 - <T as PlaylistService>::playlist_resume(&inner, request).await 6426 6426 + <T as PlaylistService>::playlist_resume(&inner, request) 6427 6427 + .await 5494 6428 }; 5495 6429 Box::pin(fut) 5496 6430 } ··· 5520 6454 "/rockbox.v1alpha1.PlaylistService/ResumeTrack" => { 5521 6455 #[allow(non_camel_case_types)] 5522 6456 struct ResumeTrackSvc<T: PlaylistService>(pub Arc<T>); 5523 5523 - impl<T: PlaylistService> tonic::server::UnaryService<super::ResumeTrackRequest> 5524 5524 - for ResumeTrackSvc<T> 5525 5525 - { 6457 6457 + impl< 6458 6458 + T: PlaylistService, 6459 6459 + > tonic::server::UnaryService<super::ResumeTrackRequest> 6460 6460 + for ResumeTrackSvc<T> { 5526 6461 type Response = super::ResumeTrackResponse; 5527 5527 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6462 6462 + type Future = BoxFuture< 6463 6463 + tonic::Response<Self::Response>, 6464 6464 + tonic::Status, 6465 6465 + >; 5528 6466 fn call( 5529 6467 &mut self, 5530 6468 request: tonic::Request<super::ResumeTrackRequest>, ··· 5561 6499 "/rockbox.v1alpha1.PlaylistService/SetModified" => { 5562 6500 #[allow(non_camel_case_types)] 5563 6501 struct SetModifiedSvc<T: PlaylistService>(pub Arc<T>); 5564 5564 - impl<T: PlaylistService> tonic::server::UnaryService<super::SetModifiedRequest> 5565 5565 - for SetModifiedSvc<T> 5566 5566 - { 6502 6502 + impl< 6503 6503 + T: PlaylistService, 6504 6504 + > tonic::server::UnaryService<super::SetModifiedRequest> 6505 6505 + for SetModifiedSvc<T> { 5567 6506 type Response = super::SetModifiedResponse; 5568 5568 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6507 6507 + type Future = BoxFuture< 6508 6508 + tonic::Response<Self::Response>, 6509 6509 + tonic::Status, 6510 6510 + >; 5569 6511 fn call( 5570 6512 &mut self, 5571 6513 request: tonic::Request<super::SetModifiedRequest>, ··· 5602 6544 "/rockbox.v1alpha1.PlaylistService/Start" => { 5603 6545 #[allow(non_camel_case_types)] 5604 6546 struct StartSvc<T: PlaylistService>(pub Arc<T>); 5605 5605 - impl<T: PlaylistService> tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 6547 6547 + impl< 6548 6548 + T: PlaylistService, 6549 6549 + > tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 5606 6550 type Response = super::StartResponse; 5607 5607 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6551 6551 + type Future = BoxFuture< 6552 6552 + tonic::Response<Self::Response>, 6553 6553 + tonic::Status, 6554 6554 + >; 5608 6555 fn call( 5609 6556 &mut self, 5610 6557 request: tonic::Request<super::StartRequest>, 5611 6558 ) -> Self::Future { 5612 6559 let inner = Arc::clone(&self.0); 5613 5613 - let fut = 5614 5614 - async move { <T as PlaylistService>::start(&inner, request).await }; 6560 6560 + let fut = async move { 6561 6561 + <T as PlaylistService>::start(&inner, request).await 6562 6562 + }; 5615 6563 Box::pin(fut) 5616 6564 } 5617 6565 } ··· 5640 6588 "/rockbox.v1alpha1.PlaylistService/Sync" => { 5641 6589 #[allow(non_camel_case_types)] 5642 6590 struct SyncSvc<T: PlaylistService>(pub Arc<T>); 5643 5643 - impl<T: PlaylistService> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 6591 6591 + impl< 6592 6592 + T: PlaylistService, 6593 6593 + > tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 5644 6594 type Response = super::SyncResponse; 5645 5645 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6595 6595 + type Future = BoxFuture< 6596 6596 + tonic::Response<Self::Response>, 6597 6597 + tonic::Status, 6598 6598 + >; 5646 6599 fn call( 5647 6600 &mut self, 5648 6601 request: tonic::Request<super::SyncRequest>, 5649 6602 ) -> Self::Future { 5650 6603 let inner = Arc::clone(&self.0); 5651 5651 - let fut = 5652 5652 - async move { <T as PlaylistService>::sync(&inner, request).await }; 6604 6604 + let fut = async move { 6605 6605 + <T as PlaylistService>::sync(&inner, request).await 6606 6606 + }; 5653 6607 Box::pin(fut) 5654 6608 } 5655 6609 } ··· 5678 6632 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks" => { 5679 6633 #[allow(non_camel_case_types)] 5680 6634 struct RemoveAllTracksSvc<T: PlaylistService>(pub Arc<T>); 5681 5681 - impl<T: PlaylistService> 5682 5682 - tonic::server::UnaryService<super::RemoveAllTracksRequest> 5683 5683 - for RemoveAllTracksSvc<T> 5684 5684 - { 6635 6635 + impl< 6636 6636 + T: PlaylistService, 6637 6637 + > tonic::server::UnaryService<super::RemoveAllTracksRequest> 6638 6638 + for RemoveAllTracksSvc<T> { 5685 6639 type Response = super::RemoveAllTracksResponse; 5686 5686 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6640 6640 + type Future = BoxFuture< 6641 6641 + tonic::Response<Self::Response>, 6642 6642 + tonic::Status, 6643 6643 + >; 5687 6644 fn call( 5688 6645 &mut self, 5689 6646 request: tonic::Request<super::RemoveAllTracksRequest>, 5690 6647 ) -> Self::Future { 5691 6648 let inner = Arc::clone(&self.0); 5692 6649 let fut = async move { 5693 5693 - <T as PlaylistService>::remove_all_tracks(&inner, request).await 6650 6650 + <T as PlaylistService>::remove_all_tracks(&inner, request) 6651 6651 + .await 5694 6652 }; 5695 6653 Box::pin(fut) 5696 6654 } ··· 5720 6678 "/rockbox.v1alpha1.PlaylistService/RemoveTracks" => { 5721 6679 #[allow(non_camel_case_types)] 5722 6680 struct RemoveTracksSvc<T: PlaylistService>(pub Arc<T>); 5723 5723 - impl<T: PlaylistService> tonic::server::UnaryService<super::RemoveTracksRequest> 5724 5724 - for RemoveTracksSvc<T> 5725 5725 - { 6681 6681 + impl< 6682 6682 + T: PlaylistService, 6683 6683 + > tonic::server::UnaryService<super::RemoveTracksRequest> 6684 6684 + for RemoveTracksSvc<T> { 5726 6685 type Response = super::RemoveTracksResponse; 5727 5727 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6686 6686 + type Future = BoxFuture< 6687 6687 + tonic::Response<Self::Response>, 6688 6688 + tonic::Status, 6689 6689 + >; 5728 6690 fn call( 5729 6691 &mut self, 5730 6692 request: tonic::Request<super::RemoveTracksRequest>, ··· 5761 6723 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist" => { 5762 6724 #[allow(non_camel_case_types)] 5763 6725 struct CreatePlaylistSvc<T: PlaylistService>(pub Arc<T>); 5764 5764 - impl<T: PlaylistService> 5765 5765 - tonic::server::UnaryService<super::CreatePlaylistRequest> 5766 5766 - for CreatePlaylistSvc<T> 5767 5767 - { 6726 6726 + impl< 6727 6727 + T: PlaylistService, 6728 6728 + > tonic::server::UnaryService<super::CreatePlaylistRequest> 6729 6729 + for CreatePlaylistSvc<T> { 5768 6730 type Response = super::CreatePlaylistResponse; 5769 5769 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6731 6731 + type Future = BoxFuture< 6732 6732 + tonic::Response<Self::Response>, 6733 6733 + tonic::Status, 6734 6734 + >; 5770 6735 fn call( 5771 6736 &mut self, 5772 6737 request: tonic::Request<super::CreatePlaylistRequest>, 5773 6738 ) -> Self::Future { 5774 6739 let inner = Arc::clone(&self.0); 5775 6740 let fut = async move { 5776 5776 - <T as PlaylistService>::create_playlist(&inner, request).await 6741 6741 + <T as PlaylistService>::create_playlist(&inner, request) 6742 6742 + .await 5777 6743 }; 5778 6744 Box::pin(fut) 5779 6745 } ··· 5803 6769 "/rockbox.v1alpha1.PlaylistService/InsertTracks" => { 5804 6770 #[allow(non_camel_case_types)] 5805 6771 struct InsertTracksSvc<T: PlaylistService>(pub Arc<T>); 5806 5806 - impl<T: PlaylistService> tonic::server::UnaryService<super::InsertTracksRequest> 5807 5807 - for InsertTracksSvc<T> 5808 5808 - { 6772 6772 + impl< 6773 6773 + T: PlaylistService, 6774 6774 + > tonic::server::UnaryService<super::InsertTracksRequest> 6775 6775 + for InsertTracksSvc<T> { 5809 6776 type Response = super::InsertTracksResponse; 5810 5810 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6777 6777 + type Future = BoxFuture< 6778 6778 + tonic::Response<Self::Response>, 6779 6779 + tonic::Status, 6780 6780 + >; 5811 6781 fn call( 5812 6782 &mut self, 5813 6783 request: tonic::Request<super::InsertTracksRequest>, ··· 5844 6814 "/rockbox.v1alpha1.PlaylistService/InsertDirectory" => { 5845 6815 #[allow(non_camel_case_types)] 5846 6816 struct InsertDirectorySvc<T: PlaylistService>(pub Arc<T>); 5847 5847 - impl<T: PlaylistService> 5848 5848 - tonic::server::UnaryService<super::InsertDirectoryRequest> 5849 5849 - for InsertDirectorySvc<T> 5850 5850 - { 6817 6817 + impl< 6818 6818 + T: PlaylistService, 6819 6819 + > tonic::server::UnaryService<super::InsertDirectoryRequest> 6820 6820 + for InsertDirectorySvc<T> { 5851 6821 type Response = super::InsertDirectoryResponse; 5852 5852 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6822 6822 + type Future = BoxFuture< 6823 6823 + tonic::Response<Self::Response>, 6824 6824 + tonic::Status, 6825 6825 + >; 5853 6826 fn call( 5854 6827 &mut self, 5855 6828 request: tonic::Request<super::InsertDirectoryRequest>, 5856 6829 ) -> Self::Future { 5857 6830 let inner = Arc::clone(&self.0); 5858 6831 let fut = async move { 5859 5859 - <T as PlaylistService>::insert_directory(&inner, request).await 6832 6832 + <T as PlaylistService>::insert_directory(&inner, request) 6833 6833 + .await 5860 6834 }; 5861 6835 Box::pin(fut) 5862 6836 } ··· 5886 6860 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist" => { 5887 6861 #[allow(non_camel_case_types)] 5888 6862 struct InsertPlaylistSvc<T: PlaylistService>(pub Arc<T>); 5889 5889 - impl<T: PlaylistService> 5890 5890 - tonic::server::UnaryService<super::InsertPlaylistRequest> 5891 5891 - for InsertPlaylistSvc<T> 5892 5892 - { 6863 6863 + impl< 6864 6864 + T: PlaylistService, 6865 6865 + > tonic::server::UnaryService<super::InsertPlaylistRequest> 6866 6866 + for InsertPlaylistSvc<T> { 5893 6867 type Response = super::InsertPlaylistResponse; 5894 5894 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6868 6868 + type Future = BoxFuture< 6869 6869 + tonic::Response<Self::Response>, 6870 6870 + tonic::Status, 6871 6871 + >; 5895 6872 fn call( 5896 6873 &mut self, 5897 6874 request: tonic::Request<super::InsertPlaylistRequest>, 5898 6875 ) -> Self::Future { 5899 6876 let inner = Arc::clone(&self.0); 5900 6877 let fut = async move { 5901 5901 - <T as PlaylistService>::insert_playlist(&inner, request).await 6878 6878 + <T as PlaylistService>::insert_playlist(&inner, request) 6879 6879 + .await 5902 6880 }; 5903 6881 Box::pin(fut) 5904 6882 } ··· 5928 6906 "/rockbox.v1alpha1.PlaylistService/InsertAlbum" => { 5929 6907 #[allow(non_camel_case_types)] 5930 6908 struct InsertAlbumSvc<T: PlaylistService>(pub Arc<T>); 5931 5931 - impl<T: PlaylistService> tonic::server::UnaryService<super::InsertAlbumRequest> 5932 5932 - for InsertAlbumSvc<T> 5933 5933 - { 6909 6909 + impl< 6910 6910 + T: PlaylistService, 6911 6911 + > tonic::server::UnaryService<super::InsertAlbumRequest> 6912 6912 + for InsertAlbumSvc<T> { 5934 6913 type Response = super::InsertAlbumResponse; 5935 5935 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6914 6914 + type Future = BoxFuture< 6915 6915 + tonic::Response<Self::Response>, 6916 6916 + tonic::Status, 6917 6917 + >; 5936 6918 fn call( 5937 6919 &mut self, 5938 6920 request: tonic::Request<super::InsertAlbumRequest>, ··· 5969 6951 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks" => { 5970 6952 #[allow(non_camel_case_types)] 5971 6953 struct InsertArtistTracksSvc<T: PlaylistService>(pub Arc<T>); 5972 5972 - impl<T: PlaylistService> 5973 5973 - tonic::server::UnaryService<super::InsertArtistTracksRequest> 5974 5974 - for InsertArtistTracksSvc<T> 5975 5975 - { 6954 6954 + impl< 6955 6955 + T: PlaylistService, 6956 6956 + > tonic::server::UnaryService<super::InsertArtistTracksRequest> 6957 6957 + for InsertArtistTracksSvc<T> { 5976 6958 type Response = super::InsertArtistTracksResponse; 5977 5977 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6959 6959 + type Future = BoxFuture< 6960 6960 + tonic::Response<Self::Response>, 6961 6961 + tonic::Status, 6962 6962 + >; 5978 6963 fn call( 5979 6964 &mut self, 5980 6965 request: tonic::Request<super::InsertArtistTracksRequest>, 5981 6966 ) -> Self::Future { 5982 6967 let inner = Arc::clone(&self.0); 5983 6968 let fut = async move { 5984 5984 - <T as PlaylistService>::insert_artist_tracks(&inner, request).await 6969 6969 + <T as PlaylistService>::insert_artist_tracks( 6970 6970 + &inner, 6971 6971 + request, 6972 6972 + ) 6973 6973 + .await 5985 6974 }; 5986 6975 Box::pin(fut) 5987 6976 } ··· 6011 7000 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist" => { 6012 7001 #[allow(non_camel_case_types)] 6013 7002 struct ShufflePlaylistSvc<T: PlaylistService>(pub Arc<T>); 6014 6014 - impl<T: PlaylistService> 6015 6015 - tonic::server::UnaryService<super::ShufflePlaylistRequest> 6016 6016 - for ShufflePlaylistSvc<T> 6017 6017 - { 7003 7003 + impl< 7004 7004 + T: PlaylistService, 7005 7005 + > tonic::server::UnaryService<super::ShufflePlaylistRequest> 7006 7006 + for ShufflePlaylistSvc<T> { 6018 7007 type Response = super::ShufflePlaylistResponse; 6019 6019 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7008 7008 + type Future = BoxFuture< 7009 7009 + tonic::Response<Self::Response>, 7010 7010 + tonic::Status, 7011 7011 + >; 6020 7012 fn call( 6021 7013 &mut self, 6022 7014 request: tonic::Request<super::ShufflePlaylistRequest>, 6023 7015 ) -> Self::Future { 6024 7016 let inner = Arc::clone(&self.0); 6025 7017 let fut = async move { 6026 6026 - <T as PlaylistService>::shuffle_playlist(&inner, request).await 7018 7018 + <T as PlaylistService>::shuffle_playlist(&inner, request) 7019 7019 + .await 6027 7020 }; 6028 7021 Box::pin(fut) 6029 7022 } ··· 6050 7043 }; 6051 7044 Box::pin(fut) 6052 7045 } 6053 6053 - _ => Box::pin(async move { 6054 6054 - let mut response = http::Response::new(empty_body()); 6055 6055 - let headers = response.headers_mut(); 6056 6056 - headers.insert( 6057 6057 - tonic::Status::GRPC_STATUS, 6058 6058 - (tonic::Code::Unimplemented as i32).into(), 6059 6059 - ); 6060 6060 - headers.insert( 6061 6061 - http::header::CONTENT_TYPE, 6062 6062 - tonic::metadata::GRPC_CONTENT_TYPE, 6063 6063 - ); 6064 6064 - Ok(response) 6065 6065 - }), 7046 7046 + _ => { 7047 7047 + Box::pin(async move { 7048 7048 + let mut response = http::Response::new(empty_body()); 7049 7049 + let headers = response.headers_mut(); 7050 7050 + headers 7051 7051 + .insert( 7052 7052 + tonic::Status::GRPC_STATUS, 7053 7053 + (tonic::Code::Unimplemented as i32).into(), 7054 7054 + ); 7055 7055 + headers 7056 7056 + .insert( 7057 7057 + http::header::CONTENT_TYPE, 7058 7058 + tonic::metadata::GRPC_CONTENT_TYPE, 7059 7059 + ); 7060 7060 + Ok(response) 7061 7061 + }) 7062 7062 + } 6066 7063 } 6067 7064 } 6068 7065 } ··· 6240 7237 dead_code, 6241 7238 missing_docs, 6242 7239 clippy::wildcard_imports, 6243 6243 - clippy::let_unit_value 7240 7240 + clippy::let_unit_value, 6244 7241 )] 7242 7242 + use tonic::codegen::*; 6245 7243 use tonic::codegen::http::Uri; 6246 6246 - use tonic::codegen::*; 6247 7244 #[derive(Debug, Clone)] 6248 7245 pub struct SavedPlaylistServiceClient<T> { 6249 7246 inner: tonic::client::Grpc<T>, ··· 6287 7284 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 6288 7285 >, 6289 7286 >, 6290 6290 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 6291 6291 - Into<StdError> + std::marker::Send + std::marker::Sync, 7287 7287 + <T as tonic::codegen::Service< 7288 7288 + http::Request<tonic::body::BoxBody>, 7289 7289 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6292 7290 { 6293 7291 SavedPlaylistServiceClient::new(InterceptedService::new(inner, interceptor)) 6294 7292 } ··· 6326 7324 pub async fn create_playlist_folder( 6327 7325 &mut self, 6328 7326 request: impl tonic::IntoRequest<super::CreatePlaylistFolderRequest>, 6329 6329 - ) -> std::result::Result<tonic::Response<super::CreatePlaylistFolderResponse>, tonic::Status> 6330 6330 - { 6331 6331 - self.inner.ready().await.map_err(|e| { 6332 6332 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6333 6333 - })?; 7327 7327 + ) -> std::result::Result< 7328 7328 + tonic::Response<super::CreatePlaylistFolderResponse>, 7329 7329 + tonic::Status, 7330 7330 + > { 7331 7331 + self.inner 7332 7332 + .ready() 7333 7333 + .await 7334 7334 + .map_err(|e| { 7335 7335 + tonic::Status::unknown( 7336 7336 + format!("Service was not ready: {}", e.into()), 7337 7337 + ) 7338 7338 + })?; 6334 7339 let codec = tonic::codec::ProstCodec::default(); 6335 7340 let path = http::uri::PathAndQuery::from_static( 6336 7341 "/rockbox.v1alpha1.SavedPlaylistService/CreatePlaylistFolder", 6337 7342 ); 6338 7343 let mut req = request.into_request(); 6339 6339 - req.extensions_mut().insert(GrpcMethod::new( 6340 6340 - "rockbox.v1alpha1.SavedPlaylistService", 6341 6341 - "CreatePlaylistFolder", 6342 6342 - )); 7344 7344 + req.extensions_mut() 7345 7345 + .insert( 7346 7346 + GrpcMethod::new( 7347 7347 + "rockbox.v1alpha1.SavedPlaylistService", 7348 7348 + "CreatePlaylistFolder", 7349 7349 + ), 7350 7350 + ); 6343 7351 self.inner.unary(req, path, codec).await 6344 7352 } 6345 7353 pub async fn get_playlist_folders( 6346 7354 &mut self, 6347 7355 request: impl tonic::IntoRequest<super::GetPlaylistFoldersRequest>, 6348 6348 - ) -> std::result::Result<tonic::Response<super::GetPlaylistFoldersResponse>, tonic::Status> 6349 6349 - { 6350 6350 - self.inner.ready().await.map_err(|e| { 6351 6351 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6352 6352 - })?; 7356 7356 + ) -> std::result::Result< 7357 7357 + tonic::Response<super::GetPlaylistFoldersResponse>, 7358 7358 + tonic::Status, 7359 7359 + > { 7360 7360 + self.inner 7361 7361 + .ready() 7362 7362 + .await 7363 7363 + .map_err(|e| { 7364 7364 + tonic::Status::unknown( 7365 7365 + format!("Service was not ready: {}", e.into()), 7366 7366 + ) 7367 7367 + })?; 6353 7368 let codec = tonic::codec::ProstCodec::default(); 6354 7369 let path = http::uri::PathAndQuery::from_static( 6355 7370 "/rockbox.v1alpha1.SavedPlaylistService/GetPlaylistFolders", 6356 7371 ); 6357 7372 let mut req = request.into_request(); 6358 6358 - req.extensions_mut().insert(GrpcMethod::new( 6359 6359 - "rockbox.v1alpha1.SavedPlaylistService", 6360 6360 - "GetPlaylistFolders", 6361 6361 - )); 7373 7373 + req.extensions_mut() 7374 7374 + .insert( 7375 7375 + GrpcMethod::new( 7376 7376 + "rockbox.v1alpha1.SavedPlaylistService", 7377 7377 + "GetPlaylistFolders", 7378 7378 + ), 7379 7379 + ); 6362 7380 self.inner.unary(req, path, codec).await 6363 7381 } 6364 7382 pub async fn delete_playlist_folder( 6365 7383 &mut self, 6366 7384 request: impl tonic::IntoRequest<super::DeletePlaylistFolderRequest>, 6367 6367 - ) -> std::result::Result<tonic::Response<super::DeletePlaylistFolderResponse>, tonic::Status> 6368 6368 - { 6369 6369 - self.inner.ready().await.map_err(|e| { 6370 6370 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6371 6371 - })?; 7385 7385 + ) -> std::result::Result< 7386 7386 + tonic::Response<super::DeletePlaylistFolderResponse>, 7387 7387 + tonic::Status, 7388 7388 + > { 7389 7389 + self.inner 7390 7390 + .ready() 7391 7391 + .await 7392 7392 + .map_err(|e| { 7393 7393 + tonic::Status::unknown( 7394 7394 + format!("Service was not ready: {}", e.into()), 7395 7395 + ) 7396 7396 + })?; 6372 7397 let codec = tonic::codec::ProstCodec::default(); 6373 7398 let path = http::uri::PathAndQuery::from_static( 6374 7399 "/rockbox.v1alpha1.SavedPlaylistService/DeletePlaylistFolder", 6375 7400 ); 6376 7401 let mut req = request.into_request(); 6377 6377 - req.extensions_mut().insert(GrpcMethod::new( 6378 6378 - "rockbox.v1alpha1.SavedPlaylistService", 6379 6379 - "DeletePlaylistFolder", 6380 6380 - )); 7402 7402 + req.extensions_mut() 7403 7403 + .insert( 7404 7404 + GrpcMethod::new( 7405 7405 + "rockbox.v1alpha1.SavedPlaylistService", 7406 7406 + "DeletePlaylistFolder", 7407 7407 + ), 7408 7408 + ); 6381 7409 self.inner.unary(req, path, codec).await 6382 7410 } 6383 7411 pub async fn get_saved_playlists( 6384 7412 &mut self, 6385 7413 request: impl tonic::IntoRequest<super::GetSavedPlaylistsRequest>, 6386 6386 - ) -> std::result::Result<tonic::Response<super::GetSavedPlaylistsResponse>, tonic::Status> 6387 6387 - { 6388 6388 - self.inner.ready().await.map_err(|e| { 6389 6389 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6390 6390 - })?; 7414 7414 + ) -> std::result::Result< 7415 7415 + tonic::Response<super::GetSavedPlaylistsResponse>, 7416 7416 + tonic::Status, 7417 7417 + > { 7418 7418 + self.inner 7419 7419 + .ready() 7420 7420 + .await 7421 7421 + .map_err(|e| { 7422 7422 + tonic::Status::unknown( 7423 7423 + format!("Service was not ready: {}", e.into()), 7424 7424 + ) 7425 7425 + })?; 6391 7426 let codec = tonic::codec::ProstCodec::default(); 6392 7427 let path = http::uri::PathAndQuery::from_static( 6393 7428 "/rockbox.v1alpha1.SavedPlaylistService/GetSavedPlaylists", 6394 7429 ); 6395 7430 let mut req = request.into_request(); 6396 6396 - req.extensions_mut().insert(GrpcMethod::new( 6397 6397 - "rockbox.v1alpha1.SavedPlaylistService", 6398 6398 - "GetSavedPlaylists", 6399 6399 - )); 7431 7431 + req.extensions_mut() 7432 7432 + .insert( 7433 7433 + GrpcMethod::new( 7434 7434 + "rockbox.v1alpha1.SavedPlaylistService", 7435 7435 + "GetSavedPlaylists", 7436 7436 + ), 7437 7437 + ); 6400 7438 self.inner.unary(req, path, codec).await 6401 7439 } 6402 7440 pub async fn get_saved_playlist( 6403 7441 &mut self, 6404 7442 request: impl tonic::IntoRequest<super::GetSavedPlaylistRequest>, 6405 6405 - ) -> std::result::Result<tonic::Response<super::GetSavedPlaylistResponse>, tonic::Status> 6406 6406 - { 6407 6407 - self.inner.ready().await.map_err(|e| { 6408 6408 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6409 6409 - })?; 7443 7443 + ) -> std::result::Result< 7444 7444 + tonic::Response<super::GetSavedPlaylistResponse>, 7445 7445 + tonic::Status, 7446 7446 + > { 7447 7447 + self.inner 7448 7448 + .ready() 7449 7449 + .await 7450 7450 + .map_err(|e| { 7451 7451 + tonic::Status::unknown( 7452 7452 + format!("Service was not ready: {}", e.into()), 7453 7453 + ) 7454 7454 + })?; 6410 7455 let codec = tonic::codec::ProstCodec::default(); 6411 7456 let path = http::uri::PathAndQuery::from_static( 6412 7457 "/rockbox.v1alpha1.SavedPlaylistService/GetSavedPlaylist", 6413 7458 ); 6414 7459 let mut req = request.into_request(); 6415 6415 - req.extensions_mut().insert(GrpcMethod::new( 6416 6416 - "rockbox.v1alpha1.SavedPlaylistService", 6417 6417 - "GetSavedPlaylist", 6418 6418 - )); 7460 7460 + req.extensions_mut() 7461 7461 + .insert( 7462 7462 + GrpcMethod::new( 7463 7463 + "rockbox.v1alpha1.SavedPlaylistService", 7464 7464 + "GetSavedPlaylist", 7465 7465 + ), 7466 7466 + ); 6419 7467 self.inner.unary(req, path, codec).await 6420 7468 } 6421 7469 pub async fn create_saved_playlist( 6422 7470 &mut self, 6423 7471 request: impl tonic::IntoRequest<super::CreateSavedPlaylistRequest>, 6424 6424 - ) -> std::result::Result<tonic::Response<super::CreateSavedPlaylistResponse>, tonic::Status> 6425 6425 - { 6426 6426 - self.inner.ready().await.map_err(|e| { 6427 6427 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6428 6428 - })?; 7472 7472 + ) -> std::result::Result< 7473 7473 + tonic::Response<super::CreateSavedPlaylistResponse>, 7474 7474 + tonic::Status, 7475 7475 + > { 7476 7476 + self.inner 7477 7477 + .ready() 7478 7478 + .await 7479 7479 + .map_err(|e| { 7480 7480 + tonic::Status::unknown( 7481 7481 + format!("Service was not ready: {}", e.into()), 7482 7482 + ) 7483 7483 + })?; 6429 7484 let codec = tonic::codec::ProstCodec::default(); 6430 7485 let path = http::uri::PathAndQuery::from_static( 6431 7486 "/rockbox.v1alpha1.SavedPlaylistService/CreateSavedPlaylist", 6432 7487 ); 6433 7488 let mut req = request.into_request(); 6434 6434 - req.extensions_mut().insert(GrpcMethod::new( 6435 6435 - "rockbox.v1alpha1.SavedPlaylistService", 6436 6436 - "CreateSavedPlaylist", 6437 6437 - )); 7489 7489 + req.extensions_mut() 7490 7490 + .insert( 7491 7491 + GrpcMethod::new( 7492 7492 + "rockbox.v1alpha1.SavedPlaylistService", 7493 7493 + "CreateSavedPlaylist", 7494 7494 + ), 7495 7495 + ); 6438 7496 self.inner.unary(req, path, codec).await 6439 7497 } 6440 7498 pub async fn update_saved_playlist( 6441 7499 &mut self, 6442 7500 request: impl tonic::IntoRequest<super::UpdateSavedPlaylistRequest>, 6443 6443 - ) -> std::result::Result<tonic::Response<super::UpdateSavedPlaylistResponse>, tonic::Status> 6444 6444 - { 6445 6445 - self.inner.ready().await.map_err(|e| { 6446 6446 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6447 6447 - })?; 7501 7501 + ) -> std::result::Result< 7502 7502 + tonic::Response<super::UpdateSavedPlaylistResponse>, 7503 7503 + tonic::Status, 7504 7504 + > { 7505 7505 + self.inner 7506 7506 + .ready() 7507 7507 + .await 7508 7508 + .map_err(|e| { 7509 7509 + tonic::Status::unknown( 7510 7510 + format!("Service was not ready: {}", e.into()), 7511 7511 + ) 7512 7512 + })?; 6448 7513 let codec = tonic::codec::ProstCodec::default(); 6449 7514 let path = http::uri::PathAndQuery::from_static( 6450 7515 "/rockbox.v1alpha1.SavedPlaylistService/UpdateSavedPlaylist", 6451 7516 ); 6452 7517 let mut req = request.into_request(); 6453 6453 - req.extensions_mut().insert(GrpcMethod::new( 6454 6454 - "rockbox.v1alpha1.SavedPlaylistService", 6455 6455 - "UpdateSavedPlaylist", 6456 6456 - )); 7518 7518 + req.extensions_mut() 7519 7519 + .insert( 7520 7520 + GrpcMethod::new( 7521 7521 + "rockbox.v1alpha1.SavedPlaylistService", 7522 7522 + "UpdateSavedPlaylist", 7523 7523 + ), 7524 7524 + ); 6457 7525 self.inner.unary(req, path, codec).await 6458 7526 } 6459 7527 pub async fn delete_saved_playlist( 6460 7528 &mut self, 6461 7529 request: impl tonic::IntoRequest<super::DeleteSavedPlaylistRequest>, 6462 6462 - ) -> std::result::Result<tonic::Response<super::DeleteSavedPlaylistResponse>, tonic::Status> 6463 6463 - { 6464 6464 - self.inner.ready().await.map_err(|e| { 6465 6465 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6466 6466 - })?; 7530 7530 + ) -> std::result::Result< 7531 7531 + tonic::Response<super::DeleteSavedPlaylistResponse>, 7532 7532 + tonic::Status, 7533 7533 + > { 7534 7534 + self.inner 7535 7535 + .ready() 7536 7536 + .await 7537 7537 + .map_err(|e| { 7538 7538 + tonic::Status::unknown( 7539 7539 + format!("Service was not ready: {}", e.into()), 7540 7540 + ) 7541 7541 + })?; 6467 7542 let codec = tonic::codec::ProstCodec::default(); 6468 7543 let path = http::uri::PathAndQuery::from_static( 6469 7544 "/rockbox.v1alpha1.SavedPlaylistService/DeleteSavedPlaylist", 6470 7545 ); 6471 7546 let mut req = request.into_request(); 6472 6472 - req.extensions_mut().insert(GrpcMethod::new( 6473 6473 - "rockbox.v1alpha1.SavedPlaylistService", 6474 6474 - "DeleteSavedPlaylist", 6475 6475 - )); 7547 7547 + req.extensions_mut() 7548 7548 + .insert( 7549 7549 + GrpcMethod::new( 7550 7550 + "rockbox.v1alpha1.SavedPlaylistService", 7551 7551 + "DeleteSavedPlaylist", 7552 7552 + ), 7553 7553 + ); 6476 7554 self.inner.unary(req, path, codec).await 6477 7555 } 6478 7556 pub async fn get_saved_playlist_tracks( ··· 6482 7560 tonic::Response<super::GetSavedPlaylistTracksResponse>, 6483 7561 tonic::Status, 6484 7562 > { 6485 6485 - self.inner.ready().await.map_err(|e| { 6486 6486 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6487 6487 - })?; 7563 7563 + self.inner 7564 7564 + .ready() 7565 7565 + .await 7566 7566 + .map_err(|e| { 7567 7567 + tonic::Status::unknown( 7568 7568 + format!("Service was not ready: {}", e.into()), 7569 7569 + ) 7570 7570 + })?; 6488 7571 let codec = tonic::codec::ProstCodec::default(); 6489 7572 let path = http::uri::PathAndQuery::from_static( 6490 7573 "/rockbox.v1alpha1.SavedPlaylistService/GetSavedPlaylistTracks", 6491 7574 ); 6492 7575 let mut req = request.into_request(); 6493 6493 - req.extensions_mut().insert(GrpcMethod::new( 6494 6494 - "rockbox.v1alpha1.SavedPlaylistService", 6495 6495 - "GetSavedPlaylistTracks", 6496 6496 - )); 7576 7576 + req.extensions_mut() 7577 7577 + .insert( 7578 7578 + GrpcMethod::new( 7579 7579 + "rockbox.v1alpha1.SavedPlaylistService", 7580 7580 + "GetSavedPlaylistTracks", 7581 7581 + ), 7582 7582 + ); 6497 7583 self.inner.unary(req, path, codec).await 6498 7584 } 6499 7585 pub async fn add_tracks_to_saved_playlist( ··· 6503 7589 tonic::Response<super::AddTracksToSavedPlaylistResponse>, 6504 7590 tonic::Status, 6505 7591 > { 6506 6506 - self.inner.ready().await.map_err(|e| { 6507 6507 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6508 6508 - })?; 7592 7592 + self.inner 7593 7593 + .ready() 7594 7594 + .await 7595 7595 + .map_err(|e| { 7596 7596 + tonic::Status::unknown( 7597 7597 + format!("Service was not ready: {}", e.into()), 7598 7598 + ) 7599 7599 + })?; 6509 7600 let codec = tonic::codec::ProstCodec::default(); 6510 7601 let path = http::uri::PathAndQuery::from_static( 6511 7602 "/rockbox.v1alpha1.SavedPlaylistService/AddTracksToSavedPlaylist", 6512 7603 ); 6513 7604 let mut req = request.into_request(); 6514 6514 - req.extensions_mut().insert(GrpcMethod::new( 6515 6515 - "rockbox.v1alpha1.SavedPlaylistService", 6516 6516 - "AddTracksToSavedPlaylist", 6517 6517 - )); 7605 7605 + req.extensions_mut() 7606 7606 + .insert( 7607 7607 + GrpcMethod::new( 7608 7608 + "rockbox.v1alpha1.SavedPlaylistService", 7609 7609 + "AddTracksToSavedPlaylist", 7610 7610 + ), 7611 7611 + ); 6518 7612 self.inner.unary(req, path, codec).await 6519 7613 } 6520 7614 pub async fn remove_track_from_saved_playlist( ··· 6524 7618 tonic::Response<super::RemoveTrackFromSavedPlaylistResponse>, 6525 7619 tonic::Status, 6526 7620 > { 6527 6527 - self.inner.ready().await.map_err(|e| { 6528 6528 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6529 6529 - })?; 7621 7621 + self.inner 7622 7622 + .ready() 7623 7623 + .await 7624 7624 + .map_err(|e| { 7625 7625 + tonic::Status::unknown( 7626 7626 + format!("Service was not ready: {}", e.into()), 7627 7627 + ) 7628 7628 + })?; 6530 7629 let codec = tonic::codec::ProstCodec::default(); 6531 7630 let path = http::uri::PathAndQuery::from_static( 6532 7631 "/rockbox.v1alpha1.SavedPlaylistService/RemoveTrackFromSavedPlaylist", 6533 7632 ); 6534 7633 let mut req = request.into_request(); 6535 6535 - req.extensions_mut().insert(GrpcMethod::new( 6536 6536 - "rockbox.v1alpha1.SavedPlaylistService", 6537 6537 - "RemoveTrackFromSavedPlaylist", 6538 6538 - )); 7634 7634 + req.extensions_mut() 7635 7635 + .insert( 7636 7636 + GrpcMethod::new( 7637 7637 + "rockbox.v1alpha1.SavedPlaylistService", 7638 7638 + "RemoveTrackFromSavedPlaylist", 7639 7639 + ), 7640 7640 + ); 6539 7641 self.inner.unary(req, path, codec).await 6540 7642 } 6541 7643 pub async fn play_saved_playlist( 6542 7644 &mut self, 6543 7645 request: impl tonic::IntoRequest<super::PlaySavedPlaylistRequest>, 6544 6544 - ) -> std::result::Result<tonic::Response<super::PlaySavedPlaylistResponse>, tonic::Status> 6545 6545 - { 6546 6546 - self.inner.ready().await.map_err(|e| { 6547 6547 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6548 6548 - })?; 7646 7646 + ) -> std::result::Result< 7647 7647 + tonic::Response<super::PlaySavedPlaylistResponse>, 7648 7648 + tonic::Status, 7649 7649 + > { 7650 7650 + self.inner 7651 7651 + .ready() 7652 7652 + .await 7653 7653 + .map_err(|e| { 7654 7654 + tonic::Status::unknown( 7655 7655 + format!("Service was not ready: {}", e.into()), 7656 7656 + ) 7657 7657 + })?; 6549 7658 let codec = tonic::codec::ProstCodec::default(); 6550 7659 let path = http::uri::PathAndQuery::from_static( 6551 7660 "/rockbox.v1alpha1.SavedPlaylistService/PlaySavedPlaylist", 6552 7661 ); 6553 7662 let mut req = request.into_request(); 6554 6554 - req.extensions_mut().insert(GrpcMethod::new( 6555 6555 - "rockbox.v1alpha1.SavedPlaylistService", 6556 6556 - "PlaySavedPlaylist", 6557 6557 - )); 7663 7663 + req.extensions_mut() 7664 7664 + .insert( 7665 7665 + GrpcMethod::new( 7666 7666 + "rockbox.v1alpha1.SavedPlaylistService", 7667 7667 + "PlaySavedPlaylist", 7668 7668 + ), 7669 7669 + ); 6558 7670 self.inner.unary(req, path, codec).await 6559 7671 } 6560 7672 } ··· 6566 7678 dead_code, 6567 7679 missing_docs, 6568 7680 clippy::wildcard_imports, 6569 6569 - clippy::let_unit_value 7681 7681 + clippy::let_unit_value, 6570 7682 )] 6571 7683 use tonic::codegen::*; 6572 7684 /// Generated trait containing gRPC methods that should be implemented for use with SavedPlaylistServiceServer. ··· 6575 7687 async fn create_playlist_folder( 6576 7688 &self, 6577 7689 request: tonic::Request<super::CreatePlaylistFolderRequest>, 6578 6578 - ) -> std::result::Result<tonic::Response<super::CreatePlaylistFolderResponse>, tonic::Status>; 7690 7690 + ) -> std::result::Result< 7691 7691 + tonic::Response<super::CreatePlaylistFolderResponse>, 7692 7692 + tonic::Status, 7693 7693 + >; 6579 7694 async fn get_playlist_folders( 6580 7695 &self, 6581 7696 request: tonic::Request<super::GetPlaylistFoldersRequest>, 6582 6582 - ) -> std::result::Result<tonic::Response<super::GetPlaylistFoldersResponse>, tonic::Status>; 7697 7697 + ) -> std::result::Result< 7698 7698 + tonic::Response<super::GetPlaylistFoldersResponse>, 7699 7699 + tonic::Status, 7700 7700 + >; 6583 7701 async fn delete_playlist_folder( 6584 7702 &self, 6585 7703 request: tonic::Request<super::DeletePlaylistFolderRequest>, 6586 6586 - ) -> std::result::Result<tonic::Response<super::DeletePlaylistFolderResponse>, tonic::Status>; 7704 7704 + ) -> std::result::Result< 7705 7705 + tonic::Response<super::DeletePlaylistFolderResponse>, 7706 7706 + tonic::Status, 7707 7707 + >; 6587 7708 async fn get_saved_playlists( 6588 7709 &self, 6589 7710 request: tonic::Request<super::GetSavedPlaylistsRequest>, 6590 6590 - ) -> std::result::Result<tonic::Response<super::GetSavedPlaylistsResponse>, tonic::Status>; 7711 7711 + ) -> std::result::Result< 7712 7712 + tonic::Response<super::GetSavedPlaylistsResponse>, 7713 7713 + tonic::Status, 7714 7714 + >; 6591 7715 async fn get_saved_playlist( 6592 7716 &self, 6593 7717 request: tonic::Request<super::GetSavedPlaylistRequest>, 6594 6594 - ) -> std::result::Result<tonic::Response<super::GetSavedPlaylistResponse>, tonic::Status>; 7718 7718 + ) -> std::result::Result< 7719 7719 + tonic::Response<super::GetSavedPlaylistResponse>, 7720 7720 + tonic::Status, 7721 7721 + >; 6595 7722 async fn create_saved_playlist( 6596 7723 &self, 6597 7724 request: tonic::Request<super::CreateSavedPlaylistRequest>, 6598 6598 - ) -> std::result::Result<tonic::Response<super::CreateSavedPlaylistResponse>, tonic::Status>; 7725 7725 + ) -> std::result::Result< 7726 7726 + tonic::Response<super::CreateSavedPlaylistResponse>, 7727 7727 + tonic::Status, 7728 7728 + >; 6599 7729 async fn update_saved_playlist( 6600 7730 &self, 6601 7731 request: tonic::Request<super::UpdateSavedPlaylistRequest>, 6602 6602 - ) -> std::result::Result<tonic::Response<super::UpdateSavedPlaylistResponse>, tonic::Status>; 7732 7732 + ) -> std::result::Result< 7733 7733 + tonic::Response<super::UpdateSavedPlaylistResponse>, 7734 7734 + tonic::Status, 7735 7735 + >; 6603 7736 async fn delete_saved_playlist( 6604 7737 &self, 6605 7738 request: tonic::Request<super::DeleteSavedPlaylistRequest>, 6606 6606 - ) -> std::result::Result<tonic::Response<super::DeleteSavedPlaylistResponse>, tonic::Status>; 7739 7739 + ) -> std::result::Result< 7740 7740 + tonic::Response<super::DeleteSavedPlaylistResponse>, 7741 7741 + tonic::Status, 7742 7742 + >; 6607 7743 async fn get_saved_playlist_tracks( 6608 7744 &self, 6609 7745 request: tonic::Request<super::GetSavedPlaylistTracksRequest>, ··· 6628 7764 async fn play_saved_playlist( 6629 7765 &self, 6630 7766 request: tonic::Request<super::PlaySavedPlaylistRequest>, 6631 6631 - ) -> std::result::Result<tonic::Response<super::PlaySavedPlaylistResponse>, tonic::Status>; 7767 7767 + ) -> std::result::Result< 7768 7768 + tonic::Response<super::PlaySavedPlaylistResponse>, 7769 7769 + tonic::Status, 7770 7770 + >; 6632 7771 } 6633 7772 #[derive(Debug)] 6634 7773 pub struct SavedPlaylistServiceServer<T> { ··· 6651 7790 max_encoding_message_size: None, 6652 7791 } 6653 7792 } 6654 6654 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 7793 7793 + pub fn with_interceptor<F>( 7794 7794 + inner: T, 7795 7795 + interceptor: F, 7796 7796 + ) -> InterceptedService<Self, F> 6655 7797 where 6656 7798 F: tonic::service::Interceptor, 6657 7799 { ··· 6686 7828 self 6687 7829 } 6688 7830 } 6689 6689 - impl<T, B> tonic::codegen::Service<http::Request<B>> for SavedPlaylistServiceServer<T> 7831 7831 + impl<T, B> tonic::codegen::Service<http::Request<B>> 7832 7832 + for SavedPlaylistServiceServer<T> 6690 7833 where 6691 7834 T: SavedPlaylistService, 6692 7835 B: Body + std::marker::Send + 'static, ··· 6706 7849 "/rockbox.v1alpha1.SavedPlaylistService/CreatePlaylistFolder" => { 6707 7850 #[allow(non_camel_case_types)] 6708 7851 struct CreatePlaylistFolderSvc<T: SavedPlaylistService>(pub Arc<T>); 6709 6709 - impl<T: SavedPlaylistService> 6710 6710 - tonic::server::UnaryService<super::CreatePlaylistFolderRequest> 6711 6711 - for CreatePlaylistFolderSvc<T> 6712 6712 - { 7852 7852 + impl< 7853 7853 + T: SavedPlaylistService, 7854 7854 + > tonic::server::UnaryService<super::CreatePlaylistFolderRequest> 7855 7855 + for CreatePlaylistFolderSvc<T> { 6713 7856 type Response = super::CreatePlaylistFolderResponse; 6714 6714 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7857 7857 + type Future = BoxFuture< 7858 7858 + tonic::Response<Self::Response>, 7859 7859 + tonic::Status, 7860 7860 + >; 6715 7861 fn call( 6716 7862 &mut self, 6717 7863 request: tonic::Request<super::CreatePlaylistFolderRequest>, 6718 7864 ) -> Self::Future { 6719 7865 let inner = Arc::clone(&self.0); 6720 7866 let fut = async move { 6721 6721 - <T as SavedPlaylistService>::create_playlist_folder(&inner, request) 7867 7867 + <T as SavedPlaylistService>::create_playlist_folder( 7868 7868 + &inner, 7869 7869 + request, 7870 7870 + ) 6722 7871 .await 6723 7872 }; 6724 7873 Box::pin(fut) ··· 6749 7898 "/rockbox.v1alpha1.SavedPlaylistService/GetPlaylistFolders" => { 6750 7899 #[allow(non_camel_case_types)] 6751 7900 struct GetPlaylistFoldersSvc<T: SavedPlaylistService>(pub Arc<T>); 6752 6752 - impl<T: SavedPlaylistService> 6753 6753 - tonic::server::UnaryService<super::GetPlaylistFoldersRequest> 6754 6754 - for GetPlaylistFoldersSvc<T> 6755 6755 - { 7901 7901 + impl< 7902 7902 + T: SavedPlaylistService, 7903 7903 + > tonic::server::UnaryService<super::GetPlaylistFoldersRequest> 7904 7904 + for GetPlaylistFoldersSvc<T> { 6756 7905 type Response = super::GetPlaylistFoldersResponse; 6757 6757 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7906 7906 + type Future = BoxFuture< 7907 7907 + tonic::Response<Self::Response>, 7908 7908 + tonic::Status, 7909 7909 + >; 6758 7910 fn call( 6759 7911 &mut self, 6760 7912 request: tonic::Request<super::GetPlaylistFoldersRequest>, 6761 7913 ) -> Self::Future { 6762 7914 let inner = Arc::clone(&self.0); 6763 7915 let fut = async move { 6764 6764 - <T as SavedPlaylistService>::get_playlist_folders(&inner, request) 7916 7916 + <T as SavedPlaylistService>::get_playlist_folders( 7917 7917 + &inner, 7918 7918 + request, 7919 7919 + ) 6765 7920 .await 6766 7921 }; 6767 7922 Box::pin(fut) ··· 6792 7947 "/rockbox.v1alpha1.SavedPlaylistService/DeletePlaylistFolder" => { 6793 7948 #[allow(non_camel_case_types)] 6794 7949 struct DeletePlaylistFolderSvc<T: SavedPlaylistService>(pub Arc<T>); 6795 6795 - impl<T: SavedPlaylistService> 6796 6796 - tonic::server::UnaryService<super::DeletePlaylistFolderRequest> 6797 6797 - for DeletePlaylistFolderSvc<T> 6798 6798 - { 7950 7950 + impl< 7951 7951 + T: SavedPlaylistService, 7952 7952 + > tonic::server::UnaryService<super::DeletePlaylistFolderRequest> 7953 7953 + for DeletePlaylistFolderSvc<T> { 6799 7954 type Response = super::DeletePlaylistFolderResponse; 6800 6800 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7955 7955 + type Future = BoxFuture< 7956 7956 + tonic::Response<Self::Response>, 7957 7957 + tonic::Status, 7958 7958 + >; 6801 7959 fn call( 6802 7960 &mut self, 6803 7961 request: tonic::Request<super::DeletePlaylistFolderRequest>, 6804 7962 ) -> Self::Future { 6805 7963 let inner = Arc::clone(&self.0); 6806 7964 let fut = async move { 6807 6807 - <T as SavedPlaylistService>::delete_playlist_folder(&inner, request) 7965 7965 + <T as SavedPlaylistService>::delete_playlist_folder( 7966 7966 + &inner, 7967 7967 + request, 7968 7968 + ) 6808 7969 .await 6809 7970 }; 6810 7971 Box::pin(fut) ··· 6835 7996 "/rockbox.v1alpha1.SavedPlaylistService/GetSavedPlaylists" => { 6836 7997 #[allow(non_camel_case_types)] 6837 7998 struct GetSavedPlaylistsSvc<T: SavedPlaylistService>(pub Arc<T>); 6838 6838 - impl<T: SavedPlaylistService> 6839 6839 - tonic::server::UnaryService<super::GetSavedPlaylistsRequest> 6840 6840 - for GetSavedPlaylistsSvc<T> 6841 6841 - { 7999 7999 + impl< 8000 8000 + T: SavedPlaylistService, 8001 8001 + > tonic::server::UnaryService<super::GetSavedPlaylistsRequest> 8002 8002 + for GetSavedPlaylistsSvc<T> { 6842 8003 type Response = super::GetSavedPlaylistsResponse; 6843 6843 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8004 8004 + type Future = BoxFuture< 8005 8005 + tonic::Response<Self::Response>, 8006 8006 + tonic::Status, 8007 8007 + >; 6844 8008 fn call( 6845 8009 &mut self, 6846 8010 request: tonic::Request<super::GetSavedPlaylistsRequest>, 6847 8011 ) -> Self::Future { 6848 8012 let inner = Arc::clone(&self.0); 6849 8013 let fut = async move { 6850 6850 - <T as SavedPlaylistService>::get_saved_playlists(&inner, request) 8014 8014 + <T as SavedPlaylistService>::get_saved_playlists( 8015 8015 + &inner, 8016 8016 + request, 8017 8017 + ) 6851 8018 .await 6852 8019 }; 6853 8020 Box::pin(fut) ··· 6878 8045 "/rockbox.v1alpha1.SavedPlaylistService/GetSavedPlaylist" => { 6879 8046 #[allow(non_camel_case_types)] 6880 8047 struct GetSavedPlaylistSvc<T: SavedPlaylistService>(pub Arc<T>); 6881 6881 - impl<T: SavedPlaylistService> 6882 6882 - tonic::server::UnaryService<super::GetSavedPlaylistRequest> 6883 6883 - for GetSavedPlaylistSvc<T> 6884 6884 - { 8048 8048 + impl< 8049 8049 + T: SavedPlaylistService, 8050 8050 + > tonic::server::UnaryService<super::GetSavedPlaylistRequest> 8051 8051 + for GetSavedPlaylistSvc<T> { 6885 8052 type Response = super::GetSavedPlaylistResponse; 6886 6886 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8053 8053 + type Future = BoxFuture< 8054 8054 + tonic::Response<Self::Response>, 8055 8055 + tonic::Status, 8056 8056 + >; 6887 8057 fn call( 6888 8058 &mut self, 6889 8059 request: tonic::Request<super::GetSavedPlaylistRequest>, 6890 8060 ) -> Self::Future { 6891 8061 let inner = Arc::clone(&self.0); 6892 8062 let fut = async move { 6893 6893 - <T as SavedPlaylistService>::get_saved_playlist(&inner, request) 8063 8063 + <T as SavedPlaylistService>::get_saved_playlist( 8064 8064 + &inner, 8065 8065 + request, 8066 8066 + ) 6894 8067 .await 6895 8068 }; 6896 8069 Box::pin(fut) ··· 6921 8094 "/rockbox.v1alpha1.SavedPlaylistService/CreateSavedPlaylist" => { 6922 8095 #[allow(non_camel_case_types)] 6923 8096 struct CreateSavedPlaylistSvc<T: SavedPlaylistService>(pub Arc<T>); 6924 6924 - impl<T: SavedPlaylistService> 6925 6925 - tonic::server::UnaryService<super::CreateSavedPlaylistRequest> 6926 6926 - for CreateSavedPlaylistSvc<T> 6927 6927 - { 8097 8097 + impl< 8098 8098 + T: SavedPlaylistService, 8099 8099 + > tonic::server::UnaryService<super::CreateSavedPlaylistRequest> 8100 8100 + for CreateSavedPlaylistSvc<T> { 6928 8101 type Response = super::CreateSavedPlaylistResponse; 6929 6929 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8102 8102 + type Future = BoxFuture< 8103 8103 + tonic::Response<Self::Response>, 8104 8104 + tonic::Status, 8105 8105 + >; 6930 8106 fn call( 6931 8107 &mut self, 6932 8108 request: tonic::Request<super::CreateSavedPlaylistRequest>, 6933 8109 ) -> Self::Future { 6934 8110 let inner = Arc::clone(&self.0); 6935 8111 let fut = async move { 6936 6936 - <T as SavedPlaylistService>::create_saved_playlist(&inner, request) 8112 8112 + <T as SavedPlaylistService>::create_saved_playlist( 8113 8113 + &inner, 8114 8114 + request, 8115 8115 + ) 6937 8116 .await 6938 8117 }; 6939 8118 Box::pin(fut) ··· 6964 8143 "/rockbox.v1alpha1.SavedPlaylistService/UpdateSavedPlaylist" => { 6965 8144 #[allow(non_camel_case_types)] 6966 8145 struct UpdateSavedPlaylistSvc<T: SavedPlaylistService>(pub Arc<T>); 6967 6967 - impl<T: SavedPlaylistService> 6968 6968 - tonic::server::UnaryService<super::UpdateSavedPlaylistRequest> 6969 6969 - for UpdateSavedPlaylistSvc<T> 6970 6970 - { 8146 8146 + impl< 8147 8147 + T: SavedPlaylistService, 8148 8148 + > tonic::server::UnaryService<super::UpdateSavedPlaylistRequest> 8149 8149 + for UpdateSavedPlaylistSvc<T> { 6971 8150 type Response = super::UpdateSavedPlaylistResponse; 6972 6972 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8151 8151 + type Future = BoxFuture< 8152 8152 + tonic::Response<Self::Response>, 8153 8153 + tonic::Status, 8154 8154 + >; 6973 8155 fn call( 6974 8156 &mut self, 6975 8157 request: tonic::Request<super::UpdateSavedPlaylistRequest>, 6976 8158 ) -> Self::Future { 6977 8159 let inner = Arc::clone(&self.0); 6978 8160 let fut = async move { 6979 6979 - <T as SavedPlaylistService>::update_saved_playlist(&inner, request) 8161 8161 + <T as SavedPlaylistService>::update_saved_playlist( 8162 8162 + &inner, 8163 8163 + request, 8164 8164 + ) 6980 8165 .await 6981 8166 }; 6982 8167 Box::pin(fut) ··· 7007 8192 "/rockbox.v1alpha1.SavedPlaylistService/DeleteSavedPlaylist" => { 7008 8193 #[allow(non_camel_case_types)] 7009 8194 struct DeleteSavedPlaylistSvc<T: SavedPlaylistService>(pub Arc<T>); 7010 7010 - impl<T: SavedPlaylistService> 7011 7011 - tonic::server::UnaryService<super::DeleteSavedPlaylistRequest> 7012 7012 - for DeleteSavedPlaylistSvc<T> 7013 7013 - { 8195 8195 + impl< 8196 8196 + T: SavedPlaylistService, 8197 8197 + > tonic::server::UnaryService<super::DeleteSavedPlaylistRequest> 8198 8198 + for DeleteSavedPlaylistSvc<T> { 7014 8199 type Response = super::DeleteSavedPlaylistResponse; 7015 7015 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8200 8200 + type Future = BoxFuture< 8201 8201 + tonic::Response<Self::Response>, 8202 8202 + tonic::Status, 8203 8203 + >; 7016 8204 fn call( 7017 8205 &mut self, 7018 8206 request: tonic::Request<super::DeleteSavedPlaylistRequest>, 7019 8207 ) -> Self::Future { 7020 8208 let inner = Arc::clone(&self.0); 7021 8209 let fut = async move { 7022 7022 - <T as SavedPlaylistService>::delete_saved_playlist(&inner, request) 8210 8210 + <T as SavedPlaylistService>::delete_saved_playlist( 8211 8211 + &inner, 8212 8212 + request, 8213 8213 + ) 7023 8214 .await 7024 8215 }; 7025 8216 Box::pin(fut) ··· 7049 8240 } 7050 8241 "/rockbox.v1alpha1.SavedPlaylistService/GetSavedPlaylistTracks" => { 7051 8242 #[allow(non_camel_case_types)] 7052 7052 - struct GetSavedPlaylistTracksSvc<T: SavedPlaylistService>(pub Arc<T>); 7053 7053 - impl<T: SavedPlaylistService> 7054 7054 - tonic::server::UnaryService<super::GetSavedPlaylistTracksRequest> 7055 7055 - for GetSavedPlaylistTracksSvc<T> 7056 7056 - { 8243 8243 + struct GetSavedPlaylistTracksSvc<T: SavedPlaylistService>( 8244 8244 + pub Arc<T>, 8245 8245 + ); 8246 8246 + impl< 8247 8247 + T: SavedPlaylistService, 8248 8248 + > tonic::server::UnaryService<super::GetSavedPlaylistTracksRequest> 8249 8249 + for GetSavedPlaylistTracksSvc<T> { 7057 8250 type Response = super::GetSavedPlaylistTracksResponse; 7058 7058 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8251 8251 + type Future = BoxFuture< 8252 8252 + tonic::Response<Self::Response>, 8253 8253 + tonic::Status, 8254 8254 + >; 7059 8255 fn call( 7060 8256 &mut self, 7061 8257 request: tonic::Request<super::GetSavedPlaylistTracksRequest>, ··· 7063 8259 let inner = Arc::clone(&self.0); 7064 8260 let fut = async move { 7065 8261 <T as SavedPlaylistService>::get_saved_playlist_tracks( 7066 7066 - &inner, request, 7067 7067 - ) 7068 7068 - .await 8262 8262 + &inner, 8263 8263 + request, 8264 8264 + ) 8265 8265 + .await 7069 8266 }; 7070 8267 Box::pin(fut) 7071 8268 } ··· 7094 8291 } 7095 8292 "/rockbox.v1alpha1.SavedPlaylistService/AddTracksToSavedPlaylist" => { 7096 8293 #[allow(non_camel_case_types)] 7097 7097 - struct AddTracksToSavedPlaylistSvc<T: SavedPlaylistService>(pub Arc<T>); 7098 7098 - impl<T: SavedPlaylistService> 7099 7099 - tonic::server::UnaryService<super::AddTracksToSavedPlaylistRequest> 7100 7100 - for AddTracksToSavedPlaylistSvc<T> 7101 7101 - { 8294 8294 + struct AddTracksToSavedPlaylistSvc<T: SavedPlaylistService>( 8295 8295 + pub Arc<T>, 8296 8296 + ); 8297 8297 + impl< 8298 8298 + T: SavedPlaylistService, 8299 8299 + > tonic::server::UnaryService<super::AddTracksToSavedPlaylistRequest> 8300 8300 + for AddTracksToSavedPlaylistSvc<T> { 7102 8301 type Response = super::AddTracksToSavedPlaylistResponse; 7103 7103 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8302 8302 + type Future = BoxFuture< 8303 8303 + tonic::Response<Self::Response>, 8304 8304 + tonic::Status, 8305 8305 + >; 7104 8306 fn call( 7105 8307 &mut self, 7106 7106 - request: tonic::Request<super::AddTracksToSavedPlaylistRequest>, 8308 8308 + request: tonic::Request< 8309 8309 + super::AddTracksToSavedPlaylistRequest, 8310 8310 + >, 7107 8311 ) -> Self::Future { 7108 8312 let inner = Arc::clone(&self.0); 7109 8313 let fut = async move { 7110 8314 <T as SavedPlaylistService>::add_tracks_to_saved_playlist( 7111 7111 - &inner, request, 7112 7112 - ) 7113 7113 - .await 8315 8315 + &inner, 8316 8316 + request, 8317 8317 + ) 8318 8318 + .await 7114 8319 }; 7115 8320 Box::pin(fut) 7116 8321 } ··· 7139 8344 } 7140 8345 "/rockbox.v1alpha1.SavedPlaylistService/RemoveTrackFromSavedPlaylist" => { 7141 8346 #[allow(non_camel_case_types)] 7142 7142 - struct RemoveTrackFromSavedPlaylistSvc<T: SavedPlaylistService>(pub Arc<T>); 7143 7143 - impl<T: SavedPlaylistService> 7144 7144 - tonic::server::UnaryService<super::RemoveTrackFromSavedPlaylistRequest> 7145 7145 - for RemoveTrackFromSavedPlaylistSvc<T> 7146 7146 - { 8347 8347 + struct RemoveTrackFromSavedPlaylistSvc<T: SavedPlaylistService>( 8348 8348 + pub Arc<T>, 8349 8349 + ); 8350 8350 + impl< 8351 8351 + T: SavedPlaylistService, 8352 8352 + > tonic::server::UnaryService< 8353 8353 + super::RemoveTrackFromSavedPlaylistRequest, 8354 8354 + > for RemoveTrackFromSavedPlaylistSvc<T> { 7147 8355 type Response = super::RemoveTrackFromSavedPlaylistResponse; 7148 7148 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8356 8356 + type Future = BoxFuture< 8357 8357 + tonic::Response<Self::Response>, 8358 8358 + tonic::Status, 8359 8359 + >; 7149 8360 fn call( 7150 8361 &mut self, 7151 7151 - request: tonic::Request<super::RemoveTrackFromSavedPlaylistRequest>, 8362 8362 + request: tonic::Request< 8363 8363 + super::RemoveTrackFromSavedPlaylistRequest, 8364 8364 + >, 7152 8365 ) -> Self::Future { 7153 8366 let inner = Arc::clone(&self.0); 7154 8367 let fut = async move { 7155 8368 <T as SavedPlaylistService>::remove_track_from_saved_playlist( 7156 7156 - &inner, request, 7157 7157 - ) 7158 7158 - .await 8369 8369 + &inner, 8370 8370 + request, 8371 8371 + ) 8372 8372 + .await 7159 8373 }; 7160 8374 Box::pin(fut) 7161 8375 } ··· 7185 8399 "/rockbox.v1alpha1.SavedPlaylistService/PlaySavedPlaylist" => { 7186 8400 #[allow(non_camel_case_types)] 7187 8401 struct PlaySavedPlaylistSvc<T: SavedPlaylistService>(pub Arc<T>); 7188 7188 - impl<T: SavedPlaylistService> 7189 7189 - tonic::server::UnaryService<super::PlaySavedPlaylistRequest> 7190 7190 - for PlaySavedPlaylistSvc<T> 7191 7191 - { 8402 8402 + impl< 8403 8403 + T: SavedPlaylistService, 8404 8404 + > tonic::server::UnaryService<super::PlaySavedPlaylistRequest> 8405 8405 + for PlaySavedPlaylistSvc<T> { 7192 8406 type Response = super::PlaySavedPlaylistResponse; 7193 7193 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8407 8407 + type Future = BoxFuture< 8408 8408 + tonic::Response<Self::Response>, 8409 8409 + tonic::Status, 8410 8410 + >; 7194 8411 fn call( 7195 8412 &mut self, 7196 8413 request: tonic::Request<super::PlaySavedPlaylistRequest>, 7197 8414 ) -> Self::Future { 7198 8415 let inner = Arc::clone(&self.0); 7199 8416 let fut = async move { 7200 7200 - <T as SavedPlaylistService>::play_saved_playlist(&inner, request) 8417 8417 + <T as SavedPlaylistService>::play_saved_playlist( 8418 8418 + &inner, 8419 8419 + request, 8420 8420 + ) 7201 8421 .await 7202 8422 }; 7203 8423 Box::pin(fut) ··· 7225 8445 }; 7226 8446 Box::pin(fut) 7227 8447 } 7228 7228 - _ => Box::pin(async move { 7229 7229 - let mut response = http::Response::new(empty_body()); 7230 7230 - let headers = response.headers_mut(); 7231 7231 - headers.insert( 7232 7232 - tonic::Status::GRPC_STATUS, 7233 7233 - (tonic::Code::Unimplemented as i32).into(), 7234 7234 - ); 7235 7235 - headers.insert( 7236 7236 - http::header::CONTENT_TYPE, 7237 7237 - tonic::metadata::GRPC_CONTENT_TYPE, 7238 7238 - ); 7239 7239 - Ok(response) 7240 7240 - }), 8448 8448 + _ => { 8449 8449 + Box::pin(async move { 8450 8450 + let mut response = http::Response::new(empty_body()); 8451 8451 + let headers = response.headers_mut(); 8452 8452 + headers 8453 8453 + .insert( 8454 8454 + tonic::Status::GRPC_STATUS, 8455 8455 + (tonic::Code::Unimplemented as i32).into(), 8456 8456 + ); 8457 8457 + headers 8458 8458 + .insert( 8459 8459 + http::header::CONTENT_TYPE, 8460 8460 + tonic::metadata::GRPC_CONTENT_TYPE, 8461 8461 + ); 8462 8462 + Ok(response) 8463 8463 + }) 8464 8464 + } 7241 8465 } 7242 8466 } 7243 8467 } ··· 7428 8652 dead_code, 7429 8653 missing_docs, 7430 8654 clippy::wildcard_imports, 7431 7431 - clippy::let_unit_value 8655 8655 + clippy::let_unit_value, 7432 8656 )] 7433 7433 - use tonic::codegen::http::Uri; 7434 8657 use tonic::codegen::*; 8658 8658 + use tonic::codegen::http::Uri; 7435 8659 #[derive(Debug, Clone)] 7436 8660 pub struct SmartPlaylistServiceClient<T> { 7437 8661 inner: tonic::client::Grpc<T>, ··· 7475 8699 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 7476 8700 >, 7477 8701 >, 7478 7478 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 7479 7479 - Into<StdError> + std::marker::Send + std::marker::Sync, 8702 8702 + <T as tonic::codegen::Service< 8703 8703 + http::Request<tonic::body::BoxBody>, 8704 8704 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 7480 8705 { 7481 8706 SmartPlaylistServiceClient::new(InterceptedService::new(inner, interceptor)) 7482 8707 } ··· 7514 8739 pub async fn get_smart_playlists( 7515 8740 &mut self, 7516 8741 request: impl tonic::IntoRequest<super::GetSmartPlaylistsRequest>, 7517 7517 - ) -> std::result::Result<tonic::Response<super::GetSmartPlaylistsResponse>, tonic::Status> 7518 7518 - { 7519 7519 - self.inner.ready().await.map_err(|e| { 7520 7520 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7521 7521 - })?; 8742 8742 + ) -> std::result::Result< 8743 8743 + tonic::Response<super::GetSmartPlaylistsResponse>, 8744 8744 + tonic::Status, 8745 8745 + > { 8746 8746 + self.inner 8747 8747 + .ready() 8748 8748 + .await 8749 8749 + .map_err(|e| { 8750 8750 + tonic::Status::unknown( 8751 8751 + format!("Service was not ready: {}", e.into()), 8752 8752 + ) 8753 8753 + })?; 7522 8754 let codec = tonic::codec::ProstCodec::default(); 7523 8755 let path = http::uri::PathAndQuery::from_static( 7524 8756 "/rockbox.v1alpha1.SmartPlaylistService/GetSmartPlaylists", 7525 8757 ); 7526 8758 let mut req = request.into_request(); 7527 7527 - req.extensions_mut().insert(GrpcMethod::new( 7528 7528 - "rockbox.v1alpha1.SmartPlaylistService", 7529 7529 - "GetSmartPlaylists", 7530 7530 - )); 8759 8759 + req.extensions_mut() 8760 8760 + .insert( 8761 8761 + GrpcMethod::new( 8762 8762 + "rockbox.v1alpha1.SmartPlaylistService", 8763 8763 + "GetSmartPlaylists", 8764 8764 + ), 8765 8765 + ); 7531 8766 self.inner.unary(req, path, codec).await 7532 8767 } 7533 8768 pub async fn get_smart_playlist( 7534 8769 &mut self, 7535 8770 request: impl tonic::IntoRequest<super::GetSmartPlaylistRequest>, 7536 7536 - ) -> std::result::Result<tonic::Response<super::GetSmartPlaylistResponse>, tonic::Status> 7537 7537 - { 7538 7538 - self.inner.ready().await.map_err(|e| { 7539 7539 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7540 7540 - })?; 8771 8771 + ) -> std::result::Result< 8772 8772 + tonic::Response<super::GetSmartPlaylistResponse>, 8773 8773 + tonic::Status, 8774 8774 + > { 8775 8775 + self.inner 8776 8776 + .ready() 8777 8777 + .await 8778 8778 + .map_err(|e| { 8779 8779 + tonic::Status::unknown( 8780 8780 + format!("Service was not ready: {}", e.into()), 8781 8781 + ) 8782 8782 + })?; 7541 8783 let codec = tonic::codec::ProstCodec::default(); 7542 8784 let path = http::uri::PathAndQuery::from_static( 7543 8785 "/rockbox.v1alpha1.SmartPlaylistService/GetSmartPlaylist", 7544 8786 ); 7545 8787 let mut req = request.into_request(); 7546 7546 - req.extensions_mut().insert(GrpcMethod::new( 7547 7547 - "rockbox.v1alpha1.SmartPlaylistService", 7548 7548 - "GetSmartPlaylist", 7549 7549 - )); 8788 8788 + req.extensions_mut() 8789 8789 + .insert( 8790 8790 + GrpcMethod::new( 8791 8791 + "rockbox.v1alpha1.SmartPlaylistService", 8792 8792 + "GetSmartPlaylist", 8793 8793 + ), 8794 8794 + ); 7550 8795 self.inner.unary(req, path, codec).await 7551 8796 } 7552 8797 pub async fn create_smart_playlist( 7553 8798 &mut self, 7554 8799 request: impl tonic::IntoRequest<super::CreateSmartPlaylistRequest>, 7555 7555 - ) -> std::result::Result<tonic::Response<super::CreateSmartPlaylistResponse>, tonic::Status> 7556 7556 - { 7557 7557 - self.inner.ready().await.map_err(|e| { 7558 7558 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7559 7559 - })?; 8800 8800 + ) -> std::result::Result< 8801 8801 + tonic::Response<super::CreateSmartPlaylistResponse>, 8802 8802 + tonic::Status, 8803 8803 + > { 8804 8804 + self.inner 8805 8805 + .ready() 8806 8806 + .await 8807 8807 + .map_err(|e| { 8808 8808 + tonic::Status::unknown( 8809 8809 + format!("Service was not ready: {}", e.into()), 8810 8810 + ) 8811 8811 + })?; 7560 8812 let codec = tonic::codec::ProstCodec::default(); 7561 8813 let path = http::uri::PathAndQuery::from_static( 7562 8814 "/rockbox.v1alpha1.SmartPlaylistService/CreateSmartPlaylist", 7563 8815 ); 7564 8816 let mut req = request.into_request(); 7565 7565 - req.extensions_mut().insert(GrpcMethod::new( 7566 7566 - "rockbox.v1alpha1.SmartPlaylistService", 7567 7567 - "CreateSmartPlaylist", 7568 7568 - )); 8817 8817 + req.extensions_mut() 8818 8818 + .insert( 8819 8819 + GrpcMethod::new( 8820 8820 + "rockbox.v1alpha1.SmartPlaylistService", 8821 8821 + "CreateSmartPlaylist", 8822 8822 + ), 8823 8823 + ); 7569 8824 self.inner.unary(req, path, codec).await 7570 8825 } 7571 8826 pub async fn update_smart_playlist( 7572 8827 &mut self, 7573 8828 request: impl tonic::IntoRequest<super::UpdateSmartPlaylistRequest>, 7574 7574 - ) -> std::result::Result<tonic::Response<super::UpdateSmartPlaylistResponse>, tonic::Status> 7575 7575 - { 7576 7576 - self.inner.ready().await.map_err(|e| { 7577 7577 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7578 7578 - })?; 8829 8829 + ) -> std::result::Result< 8830 8830 + tonic::Response<super::UpdateSmartPlaylistResponse>, 8831 8831 + tonic::Status, 8832 8832 + > { 8833 8833 + self.inner 8834 8834 + .ready() 8835 8835 + .await 8836 8836 + .map_err(|e| { 8837 8837 + tonic::Status::unknown( 8838 8838 + format!("Service was not ready: {}", e.into()), 8839 8839 + ) 8840 8840 + })?; 7579 8841 let codec = tonic::codec::ProstCodec::default(); 7580 8842 let path = http::uri::PathAndQuery::from_static( 7581 8843 "/rockbox.v1alpha1.SmartPlaylistService/UpdateSmartPlaylist", 7582 8844 ); 7583 8845 let mut req = request.into_request(); 7584 7584 - req.extensions_mut().insert(GrpcMethod::new( 7585 7585 - "rockbox.v1alpha1.SmartPlaylistService", 7586 7586 - "UpdateSmartPlaylist", 7587 7587 - )); 8846 8846 + req.extensions_mut() 8847 8847 + .insert( 8848 8848 + GrpcMethod::new( 8849 8849 + "rockbox.v1alpha1.SmartPlaylistService", 8850 8850 + "UpdateSmartPlaylist", 8851 8851 + ), 8852 8852 + ); 7588 8853 self.inner.unary(req, path, codec).await 7589 8854 } 7590 8855 pub async fn delete_smart_playlist( 7591 8856 &mut self, 7592 8857 request: impl tonic::IntoRequest<super::DeleteSmartPlaylistRequest>, 7593 7593 - ) -> std::result::Result<tonic::Response<super::DeleteSmartPlaylistResponse>, tonic::Status> 7594 7594 - { 7595 7595 - self.inner.ready().await.map_err(|e| { 7596 7596 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7597 7597 - })?; 8858 8858 + ) -> std::result::Result< 8859 8859 + tonic::Response<super::DeleteSmartPlaylistResponse>, 8860 8860 + tonic::Status, 8861 8861 + > { 8862 8862 + self.inner 8863 8863 + .ready() 8864 8864 + .await 8865 8865 + .map_err(|e| { 8866 8866 + tonic::Status::unknown( 8867 8867 + format!("Service was not ready: {}", e.into()), 8868 8868 + ) 8869 8869 + })?; 7598 8870 let codec = tonic::codec::ProstCodec::default(); 7599 8871 let path = http::uri::PathAndQuery::from_static( 7600 8872 "/rockbox.v1alpha1.SmartPlaylistService/DeleteSmartPlaylist", 7601 8873 ); 7602 8874 let mut req = request.into_request(); 7603 7603 - req.extensions_mut().insert(GrpcMethod::new( 7604 7604 - "rockbox.v1alpha1.SmartPlaylistService", 7605 7605 - "DeleteSmartPlaylist", 7606 7606 - )); 8875 8875 + req.extensions_mut() 8876 8876 + .insert( 8877 8877 + GrpcMethod::new( 8878 8878 + "rockbox.v1alpha1.SmartPlaylistService", 8879 8879 + "DeleteSmartPlaylist", 8880 8880 + ), 8881 8881 + ); 7607 8882 self.inner.unary(req, path, codec).await 7608 8883 } 7609 8884 pub async fn get_smart_playlist_tracks( ··· 7613 8888 tonic::Response<super::GetSmartPlaylistTracksResponse>, 7614 8889 tonic::Status, 7615 8890 > { 7616 7616 - self.inner.ready().await.map_err(|e| { 7617 7617 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7618 7618 - })?; 8891 8891 + self.inner 8892 8892 + .ready() 8893 8893 + .await 8894 8894 + .map_err(|e| { 8895 8895 + tonic::Status::unknown( 8896 8896 + format!("Service was not ready: {}", e.into()), 8897 8897 + ) 8898 8898 + })?; 7619 8899 let codec = tonic::codec::ProstCodec::default(); 7620 8900 let path = http::uri::PathAndQuery::from_static( 7621 8901 "/rockbox.v1alpha1.SmartPlaylistService/GetSmartPlaylistTracks", 7622 8902 ); 7623 8903 let mut req = request.into_request(); 7624 7624 - req.extensions_mut().insert(GrpcMethod::new( 7625 7625 - "rockbox.v1alpha1.SmartPlaylistService", 7626 7626 - "GetSmartPlaylistTracks", 7627 7627 - )); 8904 8904 + req.extensions_mut() 8905 8905 + .insert( 8906 8906 + GrpcMethod::new( 8907 8907 + "rockbox.v1alpha1.SmartPlaylistService", 8908 8908 + "GetSmartPlaylistTracks", 8909 8909 + ), 8910 8910 + ); 7628 8911 self.inner.unary(req, path, codec).await 7629 8912 } 7630 8913 pub async fn play_smart_playlist( 7631 8914 &mut self, 7632 8915 request: impl tonic::IntoRequest<super::PlaySmartPlaylistRequest>, 7633 7633 - ) -> std::result::Result<tonic::Response<super::PlaySmartPlaylistResponse>, tonic::Status> 7634 7634 - { 7635 7635 - self.inner.ready().await.map_err(|e| { 7636 7636 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7637 7637 - })?; 8916 8916 + ) -> std::result::Result< 8917 8917 + tonic::Response<super::PlaySmartPlaylistResponse>, 8918 8918 + tonic::Status, 8919 8919 + > { 8920 8920 + self.inner 8921 8921 + .ready() 8922 8922 + .await 8923 8923 + .map_err(|e| { 8924 8924 + tonic::Status::unknown( 8925 8925 + format!("Service was not ready: {}", e.into()), 8926 8926 + ) 8927 8927 + })?; 7638 8928 let codec = tonic::codec::ProstCodec::default(); 7639 8929 let path = http::uri::PathAndQuery::from_static( 7640 8930 "/rockbox.v1alpha1.SmartPlaylistService/PlaySmartPlaylist", 7641 8931 ); 7642 8932 let mut req = request.into_request(); 7643 7643 - req.extensions_mut().insert(GrpcMethod::new( 7644 7644 - "rockbox.v1alpha1.SmartPlaylistService", 7645 7645 - "PlaySmartPlaylist", 7646 7646 - )); 8933 8933 + req.extensions_mut() 8934 8934 + .insert( 8935 8935 + GrpcMethod::new( 8936 8936 + "rockbox.v1alpha1.SmartPlaylistService", 8937 8937 + "PlaySmartPlaylist", 8938 8938 + ), 8939 8939 + ); 7647 8940 self.inner.unary(req, path, codec).await 7648 8941 } 7649 8942 pub async fn record_track_played( 7650 8943 &mut self, 7651 8944 request: impl tonic::IntoRequest<super::RecordTrackPlayedRequest>, 7652 7652 - ) -> std::result::Result<tonic::Response<super::RecordTrackPlayedResponse>, tonic::Status> 7653 7653 - { 7654 7654 - self.inner.ready().await.map_err(|e| { 7655 7655 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7656 7656 - })?; 8945 8945 + ) -> std::result::Result< 8946 8946 + tonic::Response<super::RecordTrackPlayedResponse>, 8947 8947 + tonic::Status, 8948 8948 + > { 8949 8949 + self.inner 8950 8950 + .ready() 8951 8951 + .await 8952 8952 + .map_err(|e| { 8953 8953 + tonic::Status::unknown( 8954 8954 + format!("Service was not ready: {}", e.into()), 8955 8955 + ) 8956 8956 + })?; 7657 8957 let codec = tonic::codec::ProstCodec::default(); 7658 8958 let path = http::uri::PathAndQuery::from_static( 7659 8959 "/rockbox.v1alpha1.SmartPlaylistService/RecordTrackPlayed", 7660 8960 ); 7661 8961 let mut req = request.into_request(); 7662 7662 - req.extensions_mut().insert(GrpcMethod::new( 7663 7663 - "rockbox.v1alpha1.SmartPlaylistService", 7664 7664 - "RecordTrackPlayed", 7665 7665 - )); 8962 8962 + req.extensions_mut() 8963 8963 + .insert( 8964 8964 + GrpcMethod::new( 8965 8965 + "rockbox.v1alpha1.SmartPlaylistService", 8966 8966 + "RecordTrackPlayed", 8967 8967 + ), 8968 8968 + ); 7666 8969 self.inner.unary(req, path, codec).await 7667 8970 } 7668 8971 pub async fn record_track_skipped( 7669 8972 &mut self, 7670 8973 request: impl tonic::IntoRequest<super::RecordTrackSkippedRequest>, 7671 7671 - ) -> std::result::Result<tonic::Response<super::RecordTrackSkippedResponse>, tonic::Status> 7672 7672 - { 7673 7673 - self.inner.ready().await.map_err(|e| { 7674 7674 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7675 7675 - })?; 8974 8974 + ) -> std::result::Result< 8975 8975 + tonic::Response<super::RecordTrackSkippedResponse>, 8976 8976 + tonic::Status, 8977 8977 + > { 8978 8978 + self.inner 8979 8979 + .ready() 8980 8980 + .await 8981 8981 + .map_err(|e| { 8982 8982 + tonic::Status::unknown( 8983 8983 + format!("Service was not ready: {}", e.into()), 8984 8984 + ) 8985 8985 + })?; 7676 8986 let codec = tonic::codec::ProstCodec::default(); 7677 8987 let path = http::uri::PathAndQuery::from_static( 7678 8988 "/rockbox.v1alpha1.SmartPlaylistService/RecordTrackSkipped", 7679 8989 ); 7680 8990 let mut req = request.into_request(); 7681 7681 - req.extensions_mut().insert(GrpcMethod::new( 7682 7682 - "rockbox.v1alpha1.SmartPlaylistService", 7683 7683 - "RecordTrackSkipped", 7684 7684 - )); 8991 8991 + req.extensions_mut() 8992 8992 + .insert( 8993 8993 + GrpcMethod::new( 8994 8994 + "rockbox.v1alpha1.SmartPlaylistService", 8995 8995 + "RecordTrackSkipped", 8996 8996 + ), 8997 8997 + ); 7685 8998 self.inner.unary(req, path, codec).await 7686 8999 } 7687 9000 pub async fn get_track_stats( 7688 9001 &mut self, 7689 9002 request: impl tonic::IntoRequest<super::GetTrackStatsRequest>, 7690 7690 - ) -> std::result::Result<tonic::Response<super::GetTrackStatsResponse>, tonic::Status> 7691 7691 - { 7692 7692 - self.inner.ready().await.map_err(|e| { 7693 7693 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7694 7694 - })?; 9003 9003 + ) -> std::result::Result< 9004 9004 + tonic::Response<super::GetTrackStatsResponse>, 9005 9005 + tonic::Status, 9006 9006 + > { 9007 9007 + self.inner 9008 9008 + .ready() 9009 9009 + .await 9010 9010 + .map_err(|e| { 9011 9011 + tonic::Status::unknown( 9012 9012 + format!("Service was not ready: {}", e.into()), 9013 9013 + ) 9014 9014 + })?; 7695 9015 let codec = tonic::codec::ProstCodec::default(); 7696 9016 let path = http::uri::PathAndQuery::from_static( 7697 9017 "/rockbox.v1alpha1.SmartPlaylistService/GetTrackStats", 7698 9018 ); 7699 9019 let mut req = request.into_request(); 7700 7700 - req.extensions_mut().insert(GrpcMethod::new( 7701 7701 - "rockbox.v1alpha1.SmartPlaylistService", 7702 7702 - "GetTrackStats", 7703 7703 - )); 9020 9020 + req.extensions_mut() 9021 9021 + .insert( 9022 9022 + GrpcMethod::new( 9023 9023 + "rockbox.v1alpha1.SmartPlaylistService", 9024 9024 + "GetTrackStats", 9025 9025 + ), 9026 9026 + ); 7704 9027 self.inner.unary(req, path, codec).await 7705 9028 } 7706 9029 } ··· 7712 9035 dead_code, 7713 9036 missing_docs, 7714 9037 clippy::wildcard_imports, 7715 7715 - clippy::let_unit_value 9038 9038 + clippy::let_unit_value, 7716 9039 )] 7717 9040 use tonic::codegen::*; 7718 9041 /// Generated trait containing gRPC methods that should be implemented for use with SmartPlaylistServiceServer. ··· 7721 9044 async fn get_smart_playlists( 7722 9045 &self, 7723 9046 request: tonic::Request<super::GetSmartPlaylistsRequest>, 7724 7724 - ) -> std::result::Result<tonic::Response<super::GetSmartPlaylistsResponse>, tonic::Status>; 9047 9047 + ) -> std::result::Result< 9048 9048 + tonic::Response<super::GetSmartPlaylistsResponse>, 9049 9049 + tonic::Status, 9050 9050 + >; 7725 9051 async fn get_smart_playlist( 7726 9052 &self, 7727 9053 request: tonic::Request<super::GetSmartPlaylistRequest>, 7728 7728 - ) -> std::result::Result<tonic::Response<super::GetSmartPlaylistResponse>, tonic::Status>; 9054 9054 + ) -> std::result::Result< 9055 9055 + tonic::Response<super::GetSmartPlaylistResponse>, 9056 9056 + tonic::Status, 9057 9057 + >; 7729 9058 async fn create_smart_playlist( 7730 9059 &self, 7731 9060 request: tonic::Request<super::CreateSmartPlaylistRequest>, 7732 7732 - ) -> std::result::Result<tonic::Response<super::CreateSmartPlaylistResponse>, tonic::Status>; 9061 9061 + ) -> std::result::Result< 9062 9062 + tonic::Response<super::CreateSmartPlaylistResponse>, 9063 9063 + tonic::Status, 9064 9064 + >; 7733 9065 async fn update_smart_playlist( 7734 9066 &self, 7735 9067 request: tonic::Request<super::UpdateSmartPlaylistRequest>, 7736 7736 - ) -> std::result::Result<tonic::Response<super::UpdateSmartPlaylistResponse>, tonic::Status>; 9068 9068 + ) -> std::result::Result< 9069 9069 + tonic::Response<super::UpdateSmartPlaylistResponse>, 9070 9070 + tonic::Status, 9071 9071 + >; 7737 9072 async fn delete_smart_playlist( 7738 9073 &self, 7739 9074 request: tonic::Request<super::DeleteSmartPlaylistRequest>, 7740 7740 - ) -> std::result::Result<tonic::Response<super::DeleteSmartPlaylistResponse>, tonic::Status>; 9075 9075 + ) -> std::result::Result< 9076 9076 + tonic::Response<super::DeleteSmartPlaylistResponse>, 9077 9077 + tonic::Status, 9078 9078 + >; 7741 9079 async fn get_smart_playlist_tracks( 7742 9080 &self, 7743 9081 request: tonic::Request<super::GetSmartPlaylistTracksRequest>, ··· 7748 9086 async fn play_smart_playlist( 7749 9087 &self, 7750 9088 request: tonic::Request<super::PlaySmartPlaylistRequest>, 7751 7751 - ) -> std::result::Result<tonic::Response<super::PlaySmartPlaylistResponse>, tonic::Status>; 9089 9089 + ) -> std::result::Result< 9090 9090 + tonic::Response<super::PlaySmartPlaylistResponse>, 9091 9091 + tonic::Status, 9092 9092 + >; 7752 9093 async fn record_track_played( 7753 9094 &self, 7754 9095 request: tonic::Request<super::RecordTrackPlayedRequest>, 7755 7755 - ) -> std::result::Result<tonic::Response<super::RecordTrackPlayedResponse>, tonic::Status>; 9096 9096 + ) -> std::result::Result< 9097 9097 + tonic::Response<super::RecordTrackPlayedResponse>, 9098 9098 + tonic::Status, 9099 9099 + >; 7756 9100 async fn record_track_skipped( 7757 9101 &self, 7758 9102 request: tonic::Request<super::RecordTrackSkippedRequest>, 7759 7759 - ) -> std::result::Result<tonic::Response<super::RecordTrackSkippedResponse>, tonic::Status>; 9103 9103 + ) -> std::result::Result< 9104 9104 + tonic::Response<super::RecordTrackSkippedResponse>, 9105 9105 + tonic::Status, 9106 9106 + >; 7760 9107 async fn get_track_stats( 7761 9108 &self, 7762 9109 request: tonic::Request<super::GetTrackStatsRequest>, 7763 7763 - ) -> std::result::Result<tonic::Response<super::GetTrackStatsResponse>, tonic::Status>; 9110 9110 + ) -> std::result::Result< 9111 9111 + tonic::Response<super::GetTrackStatsResponse>, 9112 9112 + tonic::Status, 9113 9113 + >; 7764 9114 } 7765 9115 #[derive(Debug)] 7766 9116 pub struct SmartPlaylistServiceServer<T> { ··· 7783 9133 max_encoding_message_size: None, 7784 9134 } 7785 9135 } 7786 7786 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 9136 9136 + pub fn with_interceptor<F>( 9137 9137 + inner: T, 9138 9138 + interceptor: F, 9139 9139 + ) -> InterceptedService<Self, F> 7787 9140 where 7788 9141 F: tonic::service::Interceptor, 7789 9142 { ··· 7818 9171 self 7819 9172 } 7820 9173 } 7821 7821 - impl<T, B> tonic::codegen::Service<http::Request<B>> for SmartPlaylistServiceServer<T> 9174 9174 + impl<T, B> tonic::codegen::Service<http::Request<B>> 9175 9175 + for SmartPlaylistServiceServer<T> 7822 9176 where 7823 9177 T: SmartPlaylistService, 7824 9178 B: Body + std::marker::Send + 'static, ··· 7838 9192 "/rockbox.v1alpha1.SmartPlaylistService/GetSmartPlaylists" => { 7839 9193 #[allow(non_camel_case_types)] 7840 9194 struct GetSmartPlaylistsSvc<T: SmartPlaylistService>(pub Arc<T>); 7841 7841 - impl<T: SmartPlaylistService> 7842 7842 - tonic::server::UnaryService<super::GetSmartPlaylistsRequest> 7843 7843 - for GetSmartPlaylistsSvc<T> 7844 7844 - { 9195 9195 + impl< 9196 9196 + T: SmartPlaylistService, 9197 9197 + > tonic::server::UnaryService<super::GetSmartPlaylistsRequest> 9198 9198 + for GetSmartPlaylistsSvc<T> { 7845 9199 type Response = super::GetSmartPlaylistsResponse; 7846 7846 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9200 9200 + type Future = BoxFuture< 9201 9201 + tonic::Response<Self::Response>, 9202 9202 + tonic::Status, 9203 9203 + >; 7847 9204 fn call( 7848 9205 &mut self, 7849 9206 request: tonic::Request<super::GetSmartPlaylistsRequest>, 7850 9207 ) -> Self::Future { 7851 9208 let inner = Arc::clone(&self.0); 7852 9209 let fut = async move { 7853 7853 - <T as SmartPlaylistService>::get_smart_playlists(&inner, request) 9210 9210 + <T as SmartPlaylistService>::get_smart_playlists( 9211 9211 + &inner, 9212 9212 + request, 9213 9213 + ) 7854 9214 .await 7855 9215 }; 7856 9216 Box::pin(fut) ··· 7881 9241 "/rockbox.v1alpha1.SmartPlaylistService/GetSmartPlaylist" => { 7882 9242 #[allow(non_camel_case_types)] 7883 9243 struct GetSmartPlaylistSvc<T: SmartPlaylistService>(pub Arc<T>); 7884 7884 - impl<T: SmartPlaylistService> 7885 7885 - tonic::server::UnaryService<super::GetSmartPlaylistRequest> 7886 7886 - for GetSmartPlaylistSvc<T> 7887 7887 - { 9244 9244 + impl< 9245 9245 + T: SmartPlaylistService, 9246 9246 + > tonic::server::UnaryService<super::GetSmartPlaylistRequest> 9247 9247 + for GetSmartPlaylistSvc<T> { 7888 9248 type Response = super::GetSmartPlaylistResponse; 7889 7889 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9249 9249 + type Future = BoxFuture< 9250 9250 + tonic::Response<Self::Response>, 9251 9251 + tonic::Status, 9252 9252 + >; 7890 9253 fn call( 7891 9254 &mut self, 7892 9255 request: tonic::Request<super::GetSmartPlaylistRequest>, 7893 9256 ) -> Self::Future { 7894 9257 let inner = Arc::clone(&self.0); 7895 9258 let fut = async move { 7896 7896 - <T as SmartPlaylistService>::get_smart_playlist(&inner, request) 9259 9259 + <T as SmartPlaylistService>::get_smart_playlist( 9260 9260 + &inner, 9261 9261 + request, 9262 9262 + ) 7897 9263 .await 7898 9264 }; 7899 9265 Box::pin(fut) ··· 7924 9290 "/rockbox.v1alpha1.SmartPlaylistService/CreateSmartPlaylist" => { 7925 9291 #[allow(non_camel_case_types)] 7926 9292 struct CreateSmartPlaylistSvc<T: SmartPlaylistService>(pub Arc<T>); 7927 7927 - impl<T: SmartPlaylistService> 7928 7928 - tonic::server::UnaryService<super::CreateSmartPlaylistRequest> 7929 7929 - for CreateSmartPlaylistSvc<T> 7930 7930 - { 9293 9293 + impl< 9294 9294 + T: SmartPlaylistService, 9295 9295 + > tonic::server::UnaryService<super::CreateSmartPlaylistRequest> 9296 9296 + for CreateSmartPlaylistSvc<T> { 7931 9297 type Response = super::CreateSmartPlaylistResponse; 7932 7932 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9298 9298 + type Future = BoxFuture< 9299 9299 + tonic::Response<Self::Response>, 9300 9300 + tonic::Status, 9301 9301 + >; 7933 9302 fn call( 7934 9303 &mut self, 7935 9304 request: tonic::Request<super::CreateSmartPlaylistRequest>, 7936 9305 ) -> Self::Future { 7937 9306 let inner = Arc::clone(&self.0); 7938 9307 let fut = async move { 7939 7939 - <T as SmartPlaylistService>::create_smart_playlist(&inner, request) 9308 9308 + <T as SmartPlaylistService>::create_smart_playlist( 9309 9309 + &inner, 9310 9310 + request, 9311 9311 + ) 7940 9312 .await 7941 9313 }; 7942 9314 Box::pin(fut) ··· 7967 9339 "/rockbox.v1alpha1.SmartPlaylistService/UpdateSmartPlaylist" => { 7968 9340 #[allow(non_camel_case_types)] 7969 9341 struct UpdateSmartPlaylistSvc<T: SmartPlaylistService>(pub Arc<T>); 7970 7970 - impl<T: SmartPlaylistService> 7971 7971 - tonic::server::UnaryService<super::UpdateSmartPlaylistRequest> 7972 7972 - for UpdateSmartPlaylistSvc<T> 7973 7973 - { 9342 9342 + impl< 9343 9343 + T: SmartPlaylistService, 9344 9344 + > tonic::server::UnaryService<super::UpdateSmartPlaylistRequest> 9345 9345 + for UpdateSmartPlaylistSvc<T> { 7974 9346 type Response = super::UpdateSmartPlaylistResponse; 7975 7975 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9347 9347 + type Future = BoxFuture< 9348 9348 + tonic::Response<Self::Response>, 9349 9349 + tonic::Status, 9350 9350 + >; 7976 9351 fn call( 7977 9352 &mut self, 7978 9353 request: tonic::Request<super::UpdateSmartPlaylistRequest>, 7979 9354 ) -> Self::Future { 7980 9355 let inner = Arc::clone(&self.0); 7981 9356 let fut = async move { 7982 7982 - <T as SmartPlaylistService>::update_smart_playlist(&inner, request) 9357 9357 + <T as SmartPlaylistService>::update_smart_playlist( 9358 9358 + &inner, 9359 9359 + request, 9360 9360 + ) 7983 9361 .await 7984 9362 }; 7985 9363 Box::pin(fut) ··· 8010 9388 "/rockbox.v1alpha1.SmartPlaylistService/DeleteSmartPlaylist" => { 8011 9389 #[allow(non_camel_case_types)] 8012 9390 struct DeleteSmartPlaylistSvc<T: SmartPlaylistService>(pub Arc<T>); 8013 8013 - impl<T: SmartPlaylistService> 8014 8014 - tonic::server::UnaryService<super::DeleteSmartPlaylistRequest> 8015 8015 - for DeleteSmartPlaylistSvc<T> 8016 8016 - { 9391 9391 + impl< 9392 9392 + T: SmartPlaylistService, 9393 9393 + > tonic::server::UnaryService<super::DeleteSmartPlaylistRequest> 9394 9394 + for DeleteSmartPlaylistSvc<T> { 8017 9395 type Response = super::DeleteSmartPlaylistResponse; 8018 8018 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9396 9396 + type Future = BoxFuture< 9397 9397 + tonic::Response<Self::Response>, 9398 9398 + tonic::Status, 9399 9399 + >; 8019 9400 fn call( 8020 9401 &mut self, 8021 9402 request: tonic::Request<super::DeleteSmartPlaylistRequest>, 8022 9403 ) -> Self::Future { 8023 9404 let inner = Arc::clone(&self.0); 8024 9405 let fut = async move { 8025 8025 - <T as SmartPlaylistService>::delete_smart_playlist(&inner, request) 9406 9406 + <T as SmartPlaylistService>::delete_smart_playlist( 9407 9407 + &inner, 9408 9408 + request, 9409 9409 + ) 8026 9410 .await 8027 9411 }; 8028 9412 Box::pin(fut) ··· 8052 9436 } 8053 9437 "/rockbox.v1alpha1.SmartPlaylistService/GetSmartPlaylistTracks" => { 8054 9438 #[allow(non_camel_case_types)] 8055 8055 - struct GetSmartPlaylistTracksSvc<T: SmartPlaylistService>(pub Arc<T>); 8056 8056 - impl<T: SmartPlaylistService> 8057 8057 - tonic::server::UnaryService<super::GetSmartPlaylistTracksRequest> 8058 8058 - for GetSmartPlaylistTracksSvc<T> 8059 8059 - { 9439 9439 + struct GetSmartPlaylistTracksSvc<T: SmartPlaylistService>( 9440 9440 + pub Arc<T>, 9441 9441 + ); 9442 9442 + impl< 9443 9443 + T: SmartPlaylistService, 9444 9444 + > tonic::server::UnaryService<super::GetSmartPlaylistTracksRequest> 9445 9445 + for GetSmartPlaylistTracksSvc<T> { 8060 9446 type Response = super::GetSmartPlaylistTracksResponse; 8061 8061 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9447 9447 + type Future = BoxFuture< 9448 9448 + tonic::Response<Self::Response>, 9449 9449 + tonic::Status, 9450 9450 + >; 8062 9451 fn call( 8063 9452 &mut self, 8064 9453 request: tonic::Request<super::GetSmartPlaylistTracksRequest>, ··· 8066 9455 let inner = Arc::clone(&self.0); 8067 9456 let fut = async move { 8068 9457 <T as SmartPlaylistService>::get_smart_playlist_tracks( 8069 8069 - &inner, request, 8070 8070 - ) 8071 8071 - .await 9458 9458 + &inner, 9459 9459 + request, 9460 9460 + ) 9461 9461 + .await 8072 9462 }; 8073 9463 Box::pin(fut) 8074 9464 } ··· 8098 9488 "/rockbox.v1alpha1.SmartPlaylistService/PlaySmartPlaylist" => { 8099 9489 #[allow(non_camel_case_types)] 8100 9490 struct PlaySmartPlaylistSvc<T: SmartPlaylistService>(pub Arc<T>); 8101 8101 - impl<T: SmartPlaylistService> 8102 8102 - tonic::server::UnaryService<super::PlaySmartPlaylistRequest> 8103 8103 - for PlaySmartPlaylistSvc<T> 8104 8104 - { 9491 9491 + impl< 9492 9492 + T: SmartPlaylistService, 9493 9493 + > tonic::server::UnaryService<super::PlaySmartPlaylistRequest> 9494 9494 + for PlaySmartPlaylistSvc<T> { 8105 9495 type Response = super::PlaySmartPlaylistResponse; 8106 8106 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9496 9496 + type Future = BoxFuture< 9497 9497 + tonic::Response<Self::Response>, 9498 9498 + tonic::Status, 9499 9499 + >; 8107 9500 fn call( 8108 9501 &mut self, 8109 9502 request: tonic::Request<super::PlaySmartPlaylistRequest>, 8110 9503 ) -> Self::Future { 8111 9504 let inner = Arc::clone(&self.0); 8112 9505 let fut = async move { 8113 8113 - <T as SmartPlaylistService>::play_smart_playlist(&inner, request) 9506 9506 + <T as SmartPlaylistService>::play_smart_playlist( 9507 9507 + &inner, 9508 9508 + request, 9509 9509 + ) 8114 9510 .await 8115 9511 }; 8116 9512 Box::pin(fut) ··· 8141 9537 "/rockbox.v1alpha1.SmartPlaylistService/RecordTrackPlayed" => { 8142 9538 #[allow(non_camel_case_types)] 8143 9539 struct RecordTrackPlayedSvc<T: SmartPlaylistService>(pub Arc<T>); 8144 8144 - impl<T: SmartPlaylistService> 8145 8145 - tonic::server::UnaryService<super::RecordTrackPlayedRequest> 8146 8146 - for RecordTrackPlayedSvc<T> 8147 8147 - { 9540 9540 + impl< 9541 9541 + T: SmartPlaylistService, 9542 9542 + > tonic::server::UnaryService<super::RecordTrackPlayedRequest> 9543 9543 + for RecordTrackPlayedSvc<T> { 8148 9544 type Response = super::RecordTrackPlayedResponse; 8149 8149 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9545 9545 + type Future = BoxFuture< 9546 9546 + tonic::Response<Self::Response>, 9547 9547 + tonic::Status, 9548 9548 + >; 8150 9549 fn call( 8151 9550 &mut self, 8152 9551 request: tonic::Request<super::RecordTrackPlayedRequest>, 8153 9552 ) -> Self::Future { 8154 9553 let inner = Arc::clone(&self.0); 8155 9554 let fut = async move { 8156 8156 - <T as SmartPlaylistService>::record_track_played(&inner, request) 9555 9555 + <T as SmartPlaylistService>::record_track_played( 9556 9556 + &inner, 9557 9557 + request, 9558 9558 + ) 8157 9559 .await 8158 9560 }; 8159 9561 Box::pin(fut) ··· 8184 9586 "/rockbox.v1alpha1.SmartPlaylistService/RecordTrackSkipped" => { 8185 9587 #[allow(non_camel_case_types)] 8186 9588 struct RecordTrackSkippedSvc<T: SmartPlaylistService>(pub Arc<T>); 8187 8187 - impl<T: SmartPlaylistService> 8188 8188 - tonic::server::UnaryService<super::RecordTrackSkippedRequest> 8189 8189 - for RecordTrackSkippedSvc<T> 8190 8190 - { 9589 9589 + impl< 9590 9590 + T: SmartPlaylistService, 9591 9591 + > tonic::server::UnaryService<super::RecordTrackSkippedRequest> 9592 9592 + for RecordTrackSkippedSvc<T> { 8191 9593 type Response = super::RecordTrackSkippedResponse; 8192 8192 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9594 9594 + type Future = BoxFuture< 9595 9595 + tonic::Response<Self::Response>, 9596 9596 + tonic::Status, 9597 9597 + >; 8193 9598 fn call( 8194 9599 &mut self, 8195 9600 request: tonic::Request<super::RecordTrackSkippedRequest>, 8196 9601 ) -> Self::Future { 8197 9602 let inner = Arc::clone(&self.0); 8198 9603 let fut = async move { 8199 8199 - <T as SmartPlaylistService>::record_track_skipped(&inner, request) 9604 9604 + <T as SmartPlaylistService>::record_track_skipped( 9605 9605 + &inner, 9606 9606 + request, 9607 9607 + ) 8200 9608 .await 8201 9609 }; 8202 9610 Box::pin(fut) ··· 8227 9635 "/rockbox.v1alpha1.SmartPlaylistService/GetTrackStats" => { 8228 9636 #[allow(non_camel_case_types)] 8229 9637 struct GetTrackStatsSvc<T: SmartPlaylistService>(pub Arc<T>); 8230 8230 - impl<T: SmartPlaylistService> 8231 8231 - tonic::server::UnaryService<super::GetTrackStatsRequest> 8232 8232 - for GetTrackStatsSvc<T> 8233 8233 - { 9638 9638 + impl< 9639 9639 + T: SmartPlaylistService, 9640 9640 + > tonic::server::UnaryService<super::GetTrackStatsRequest> 9641 9641 + for GetTrackStatsSvc<T> { 8234 9642 type Response = super::GetTrackStatsResponse; 8235 8235 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9643 9643 + type Future = BoxFuture< 9644 9644 + tonic::Response<Self::Response>, 9645 9645 + tonic::Status, 9646 9646 + >; 8236 9647 fn call( 8237 9648 &mut self, 8238 9649 request: tonic::Request<super::GetTrackStatsRequest>, 8239 9650 ) -> Self::Future { 8240 9651 let inner = Arc::clone(&self.0); 8241 9652 let fut = async move { 8242 8242 - <T as SmartPlaylistService>::get_track_stats(&inner, request).await 9653 9653 + <T as SmartPlaylistService>::get_track_stats( 9654 9654 + &inner, 9655 9655 + request, 9656 9656 + ) 9657 9657 + .await 8243 9658 }; 8244 9659 Box::pin(fut) 8245 9660 } ··· 8266 9681 }; 8267 9682 Box::pin(fut) 8268 9683 } 8269 8269 - _ => Box::pin(async move { 8270 8270 - let mut response = http::Response::new(empty_body()); 8271 8271 - let headers = response.headers_mut(); 8272 8272 - headers.insert( 8273 8273 - tonic::Status::GRPC_STATUS, 8274 8274 - (tonic::Code::Unimplemented as i32).into(), 8275 8275 - ); 8276 8276 - headers.insert( 8277 8277 - http::header::CONTENT_TYPE, 8278 8278 - tonic::metadata::GRPC_CONTENT_TYPE, 8279 8279 - ); 8280 8280 - Ok(response) 8281 8281 - }), 9684 9684 + _ => { 9685 9685 + Box::pin(async move { 9686 9686 + let mut response = http::Response::new(empty_body()); 9687 9687 + let headers = response.headers_mut(); 9688 9688 + headers 9689 9689 + .insert( 9690 9690 + tonic::Status::GRPC_STATUS, 9691 9691 + (tonic::Code::Unimplemented as i32).into(), 9692 9692 + ); 9693 9693 + headers 9694 9694 + .insert( 9695 9695 + http::header::CONTENT_TYPE, 9696 9696 + tonic::metadata::GRPC_CONTENT_TYPE, 9697 9697 + ); 9698 9698 + Ok(response) 9699 9699 + }) 9700 9700 + } 8282 9701 } 8283 9702 } 8284 9703 } ··· 8788 10207 dead_code, 8789 10208 missing_docs, 8790 10209 clippy::wildcard_imports, 8791 8791 - clippy::let_unit_value 10210 10210 + clippy::let_unit_value, 8792 10211 )] 8793 8793 - use tonic::codegen::http::Uri; 8794 10212 use tonic::codegen::*; 10213 10213 + use tonic::codegen::http::Uri; 8795 10214 #[derive(Debug, Clone)] 8796 10215 pub struct SettingsServiceClient<T> { 8797 10216 inner: tonic::client::Grpc<T>, ··· 8835 10254 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 8836 10255 >, 8837 10256 >, 8838 8838 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 8839 8839 - Into<StdError> + std::marker::Send + std::marker::Sync, 10257 10257 + <T as tonic::codegen::Service< 10258 10258 + http::Request<tonic::body::BoxBody>, 10259 10259 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 8840 10260 { 8841 10261 SettingsServiceClient::new(InterceptedService::new(inner, interceptor)) 8842 10262 } ··· 8874 10294 pub async fn get_settings_list( 8875 10295 &mut self, 8876 10296 request: impl tonic::IntoRequest<super::GetSettingsListRequest>, 8877 8877 - ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status> 8878 8878 - { 8879 8879 - self.inner.ready().await.map_err(|e| { 8880 8880 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 8881 8881 - })?; 10297 10297 + ) -> std::result::Result< 10298 10298 + tonic::Response<super::GetSettingsListResponse>, 10299 10299 + tonic::Status, 10300 10300 + > { 10301 10301 + self.inner 10302 10302 + .ready() 10303 10303 + .await 10304 10304 + .map_err(|e| { 10305 10305 + tonic::Status::unknown( 10306 10306 + format!("Service was not ready: {}", e.into()), 10307 10307 + ) 10308 10308 + })?; 8882 10309 let codec = tonic::codec::ProstCodec::default(); 8883 10310 let path = http::uri::PathAndQuery::from_static( 8884 10311 "/rockbox.v1alpha1.SettingsService/GetSettingsList", 8885 10312 ); 8886 10313 let mut req = request.into_request(); 8887 8887 - req.extensions_mut().insert(GrpcMethod::new( 8888 8888 - "rockbox.v1alpha1.SettingsService", 8889 8889 - "GetSettingsList", 8890 8890 - )); 10314 10314 + req.extensions_mut() 10315 10315 + .insert( 10316 10316 + GrpcMethod::new( 10317 10317 + "rockbox.v1alpha1.SettingsService", 10318 10318 + "GetSettingsList", 10319 10319 + ), 10320 10320 + ); 8891 10321 self.inner.unary(req, path, codec).await 8892 10322 } 8893 10323 pub async fn get_global_settings( 8894 10324 &mut self, 8895 10325 request: impl tonic::IntoRequest<super::GetGlobalSettingsRequest>, 8896 8896 - ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status> 8897 8897 - { 8898 8898 - self.inner.ready().await.map_err(|e| { 8899 8899 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 8900 8900 - })?; 10326 10326 + ) -> std::result::Result< 10327 10327 + tonic::Response<super::GetGlobalSettingsResponse>, 10328 10328 + tonic::Status, 10329 10329 + > { 10330 10330 + self.inner 10331 10331 + .ready() 10332 10332 + .await 10333 10333 + .map_err(|e| { 10334 10334 + tonic::Status::unknown( 10335 10335 + format!("Service was not ready: {}", e.into()), 10336 10336 + ) 10337 10337 + })?; 8901 10338 let codec = tonic::codec::ProstCodec::default(); 8902 10339 let path = http::uri::PathAndQuery::from_static( 8903 10340 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings", 8904 10341 ); 8905 10342 let mut req = request.into_request(); 8906 8906 - req.extensions_mut().insert(GrpcMethod::new( 8907 8907 - "rockbox.v1alpha1.SettingsService", 8908 8908 - "GetGlobalSettings", 8909 8909 - )); 10343 10343 + req.extensions_mut() 10344 10344 + .insert( 10345 10345 + GrpcMethod::new( 10346 10346 + "rockbox.v1alpha1.SettingsService", 10347 10347 + "GetGlobalSettings", 10348 10348 + ), 10349 10349 + ); 8910 10350 self.inner.unary(req, path, codec).await 8911 10351 } 8912 10352 pub async fn save_settings( 8913 10353 &mut self, 8914 10354 request: impl tonic::IntoRequest<super::SaveSettingsRequest>, 8915 8915 - ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status> 8916 8916 - { 8917 8917 - self.inner.ready().await.map_err(|e| { 8918 8918 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 8919 8919 - })?; 10355 10355 + ) -> std::result::Result< 10356 10356 + tonic::Response<super::SaveSettingsResponse>, 10357 10357 + tonic::Status, 10358 10358 + > { 10359 10359 + self.inner 10360 10360 + .ready() 10361 10361 + .await 10362 10362 + .map_err(|e| { 10363 10363 + tonic::Status::unknown( 10364 10364 + format!("Service was not ready: {}", e.into()), 10365 10365 + ) 10366 10366 + })?; 8920 10367 let codec = tonic::codec::ProstCodec::default(); 8921 10368 let path = http::uri::PathAndQuery::from_static( 8922 10369 "/rockbox.v1alpha1.SettingsService/SaveSettings", 8923 10370 ); 8924 10371 let mut req = request.into_request(); 8925 8925 - req.extensions_mut().insert(GrpcMethod::new( 8926 8926 - "rockbox.v1alpha1.SettingsService", 8927 8927 - "SaveSettings", 8928 8928 - )); 10372 10372 + req.extensions_mut() 10373 10373 + .insert( 10374 10374 + GrpcMethod::new("rockbox.v1alpha1.SettingsService", "SaveSettings"), 10375 10375 + ); 8929 10376 self.inner.unary(req, path, codec).await 8930 10377 } 8931 10378 } ··· 8937 10384 dead_code, 8938 10385 missing_docs, 8939 10386 clippy::wildcard_imports, 8940 8940 - clippy::let_unit_value 10387 10387 + clippy::let_unit_value, 8941 10388 )] 8942 10389 use tonic::codegen::*; 8943 10390 /// Generated trait containing gRPC methods that should be implemented for use with SettingsServiceServer. ··· 8946 10393 async fn get_settings_list( 8947 10394 &self, 8948 10395 request: tonic::Request<super::GetSettingsListRequest>, 8949 8949 - ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status>; 10396 10396 + ) -> std::result::Result< 10397 10397 + tonic::Response<super::GetSettingsListResponse>, 10398 10398 + tonic::Status, 10399 10399 + >; 8950 10400 async fn get_global_settings( 8951 10401 &self, 8952 10402 request: tonic::Request<super::GetGlobalSettingsRequest>, 8953 8953 - ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status>; 10403 10403 + ) -> std::result::Result< 10404 10404 + tonic::Response<super::GetGlobalSettingsResponse>, 10405 10405 + tonic::Status, 10406 10406 + >; 8954 10407 async fn save_settings( 8955 10408 &self, 8956 10409 request: tonic::Request<super::SaveSettingsRequest>, 8957 8957 - ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>; 10410 10410 + ) -> std::result::Result< 10411 10411 + tonic::Response<super::SaveSettingsResponse>, 10412 10412 + tonic::Status, 10413 10413 + >; 8958 10414 } 8959 10415 #[derive(Debug)] 8960 10416 pub struct SettingsServiceServer<T> { ··· 8977 10433 max_encoding_message_size: None, 8978 10434 } 8979 10435 } 8980 8980 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 10436 10436 + pub fn with_interceptor<F>( 10437 10437 + inner: T, 10438 10438 + interceptor: F, 10439 10439 + ) -> InterceptedService<Self, F> 8981 10440 where 8982 10441 F: tonic::service::Interceptor, 8983 10442 { ··· 9032 10491 "/rockbox.v1alpha1.SettingsService/GetSettingsList" => { 9033 10492 #[allow(non_camel_case_types)] 9034 10493 struct GetSettingsListSvc<T: SettingsService>(pub Arc<T>); 9035 9035 - impl<T: SettingsService> 9036 9036 - tonic::server::UnaryService<super::GetSettingsListRequest> 9037 9037 - for GetSettingsListSvc<T> 9038 9038 - { 10494 10494 + impl< 10495 10495 + T: SettingsService, 10496 10496 + > tonic::server::UnaryService<super::GetSettingsListRequest> 10497 10497 + for GetSettingsListSvc<T> { 9039 10498 type Response = super::GetSettingsListResponse; 9040 9040 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 10499 10499 + type Future = BoxFuture< 10500 10500 + tonic::Response<Self::Response>, 10501 10501 + tonic::Status, 10502 10502 + >; 9041 10503 fn call( 9042 10504 &mut self, 9043 10505 request: tonic::Request<super::GetSettingsListRequest>, 9044 10506 ) -> Self::Future { 9045 10507 let inner = Arc::clone(&self.0); 9046 10508 let fut = async move { 9047 9047 - <T as SettingsService>::get_settings_list(&inner, request).await 10509 10509 + <T as SettingsService>::get_settings_list(&inner, request) 10510 10510 + .await 9048 10511 }; 9049 10512 Box::pin(fut) 9050 10513 } ··· 9074 10537 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings" => { 9075 10538 #[allow(non_camel_case_types)] 9076 10539 struct GetGlobalSettingsSvc<T: SettingsService>(pub Arc<T>); 9077 9077 - impl<T: SettingsService> 9078 9078 - tonic::server::UnaryService<super::GetGlobalSettingsRequest> 9079 9079 - for GetGlobalSettingsSvc<T> 9080 9080 - { 10540 10540 + impl< 10541 10541 + T: SettingsService, 10542 10542 + > tonic::server::UnaryService<super::GetGlobalSettingsRequest> 10543 10543 + for GetGlobalSettingsSvc<T> { 9081 10544 type Response = super::GetGlobalSettingsResponse; 9082 9082 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 10545 10545 + type Future = BoxFuture< 10546 10546 + tonic::Response<Self::Response>, 10547 10547 + tonic::Status, 10548 10548 + >; 9083 10549 fn call( 9084 10550 &mut self, 9085 10551 request: tonic::Request<super::GetGlobalSettingsRequest>, 9086 10552 ) -> Self::Future { 9087 10553 let inner = Arc::clone(&self.0); 9088 10554 let fut = async move { 9089 9089 - <T as SettingsService>::get_global_settings(&inner, request).await 10555 10555 + <T as SettingsService>::get_global_settings(&inner, request) 10556 10556 + .await 9090 10557 }; 9091 10558 Box::pin(fut) 9092 10559 } ··· 9116 10583 "/rockbox.v1alpha1.SettingsService/SaveSettings" => { 9117 10584 #[allow(non_camel_case_types)] 9118 10585 struct SaveSettingsSvc<T: SettingsService>(pub Arc<T>); 9119 9119 - impl<T: SettingsService> tonic::server::UnaryService<super::SaveSettingsRequest> 9120 9120 - for SaveSettingsSvc<T> 9121 9121 - { 10586 10586 + impl< 10587 10587 + T: SettingsService, 10588 10588 + > tonic::server::UnaryService<super::SaveSettingsRequest> 10589 10589 + for SaveSettingsSvc<T> { 9122 10590 type Response = super::SaveSettingsResponse; 9123 9123 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 10591 10591 + type Future = BoxFuture< 10592 10592 + tonic::Response<Self::Response>, 10593 10593 + tonic::Status, 10594 10594 + >; 9124 10595 fn call( 9125 10596 &mut self, 9126 10597 request: tonic::Request<super::SaveSettingsRequest>, ··· 9154 10625 }; 9155 10626 Box::pin(fut) 9156 10627 } 9157 9157 - _ => Box::pin(async move { 9158 9158 - let mut response = http::Response::new(empty_body()); 9159 9159 - let headers = response.headers_mut(); 9160 9160 - headers.insert( 9161 9161 - tonic::Status::GRPC_STATUS, 9162 9162 - (tonic::Code::Unimplemented as i32).into(), 9163 9163 - ); 9164 9164 - headers.insert( 9165 9165 - http::header::CONTENT_TYPE, 9166 9166 - tonic::metadata::GRPC_CONTENT_TYPE, 9167 9167 - ); 9168 9168 - Ok(response) 9169 9169 - }), 10628 10628 + _ => { 10629 10629 + Box::pin(async move { 10630 10630 + let mut response = http::Response::new(empty_body()); 10631 10631 + let headers = response.headers_mut(); 10632 10632 + headers 10633 10633 + .insert( 10634 10634 + tonic::Status::GRPC_STATUS, 10635 10635 + (tonic::Code::Unimplemented as i32).into(), 10636 10636 + ); 10637 10637 + headers 10638 10638 + .insert( 10639 10639 + http::header::CONTENT_TYPE, 10640 10640 + tonic::metadata::GRPC_CONTENT_TYPE, 10641 10641 + ); 10642 10642 + Ok(response) 10643 10643 + }) 10644 10644 + } 9170 10645 } 9171 10646 } 9172 10647 } ··· 9324 10799 dead_code, 9325 10800 missing_docs, 9326 10801 clippy::wildcard_imports, 9327 9327 - clippy::let_unit_value 10802 10802 + clippy::let_unit_value, 9328 10803 )] 9329 9329 - use tonic::codegen::http::Uri; 9330 10804 use tonic::codegen::*; 10805 10805 + use tonic::codegen::http::Uri; 9331 10806 #[derive(Debug, Clone)] 9332 10807 pub struct SoundServiceClient<T> { 9333 10808 inner: tonic::client::Grpc<T>, ··· 9371 10846 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 9372 10847 >, 9373 10848 >, 9374 9374 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 9375 9375 - Into<StdError> + std::marker::Send + std::marker::Sync, 10849 10849 + <T as tonic::codegen::Service< 10850 10850 + http::Request<tonic::body::BoxBody>, 10851 10851 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 9376 10852 { 9377 10853 SoundServiceClient::new(InterceptedService::new(inner, interceptor)) 9378 10854 } ··· 9410 10886 pub async fn adjust_volume( 9411 10887 &mut self, 9412 10888 request: impl tonic::IntoRequest<super::AdjustVolumeRequest>, 9413 9413 - ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status> 9414 9414 - { 9415 9415 - self.inner.ready().await.map_err(|e| { 9416 9416 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 9417 9417 - })?; 10889 10889 + ) -> std::result::Result< 10890 10890 + tonic::Response<super::AdjustVolumeResponse>, 10891 10891 + tonic::Status, 10892 10892 + > { 10893 10893 + self.inner 10894 10894 + .ready() 10895 10895 + .await 10896 10896 + .map_err(|e| { 10897 10897 + tonic::Status::unknown( 10898 10898 + format!("Service was not ready: {}", e.into()), 10899 10899 + ) 10900 10900 + })?; 9418 10901 let codec = tonic::codec::ProstCodec::default(); 9419 9419 - let path = 9420 9420 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/AdjustVolume"); 10902 10902 + let path = http::uri::PathAndQuery::from_static( 10903 10903 + "/rockbox.v1alpha1.SoundService/AdjustVolume", 10904 10904 + ); 9421 10905 let mut req = request.into_request(); 9422 9422 - req.extensions_mut().insert(GrpcMethod::new( 9423 9423 - "rockbox.v1alpha1.SoundService", 9424 9424 - "AdjustVolume", 9425 9425 - )); 10906 10906 + req.extensions_mut() 10907 10907 + .insert( 10908 10908 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "AdjustVolume"), 10909 10909 + ); 9426 10910 self.inner.unary(req, path, codec).await 9427 10911 } 9428 10912 pub async fn sound_set( 9429 10913 &mut self, 9430 10914 request: impl tonic::IntoRequest<super::SoundSetRequest>, 9431 9431 - ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status> { 9432 9432 - self.inner.ready().await.map_err(|e| { 9433 9433 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 9434 9434 - })?; 10915 10915 + ) -> std::result::Result< 10916 10916 + tonic::Response<super::SoundSetResponse>, 10917 10917 + tonic::Status, 10918 10918 + > { 10919 10919 + self.inner 10920 10920 + .ready() 10921 10921 + .await 10922 10922 + .map_err(|e| { 10923 10923 + tonic::Status::unknown( 10924 10924 + format!("Service was not ready: {}", e.into()), 10925 10925 + ) 10926 10926 + })?; 9435 10927 let codec = tonic::codec::ProstCodec::default(); 9436 9436 - let path = 9437 9437 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundSet"); 10928 10928 + let path = http::uri::PathAndQuery::from_static( 10929 10929 + "/rockbox.v1alpha1.SoundService/SoundSet", 10930 10930 + ); 9438 10931 let mut req = request.into_request(); 9439 10932 req.extensions_mut() 9440 10933 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundSet")); ··· 9443 10936 pub async fn sound_current( 9444 10937 &mut self, 9445 10938 request: impl tonic::IntoRequest<super::SoundCurrentRequest>, 9446 9446 - ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status> 9447 9447 - { 9448 9448 - self.inner.ready().await.map_err(|e| { 9449 9449 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 9450 9450 - })?; 10939 10939 + ) -> std::result::Result< 10940 10940 + tonic::Response<super::SoundCurrentResponse>, 10941 10941 + tonic::Status, 10942 10942 + > { 10943 10943 + self.inner 10944 10944 + .ready() 10945 10945 + .await 10946 10946 + .map_err(|e| { 10947 10947 + tonic::Status::unknown( 10948 10948 + format!("Service was not ready: {}", e.into()), 10949 10949 + ) 10950 10950 + })?; 9451 10951 let codec = tonic::codec::ProstCodec::default(); 9452 9452 - let path = 9453 9453 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundCurrent"); 10952 10952 + let path = http::uri::PathAndQuery::from_static( 10953 10953 + "/rockbox.v1alpha1.SoundService/SoundCurrent", 10954 10954 + ); 9454 10955 let mut req = request.into_request(); 9455 9455 - req.extensions_mut().insert(GrpcMethod::new( 9456 9456 - "rockbox.v1alpha1.SoundService", 9457 9457 - "SoundCurrent", 9458 9458 - )); 10956 10956 + req.extensions_mut() 10957 10957 + .insert( 10958 10958 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundCurrent"), 10959 10959 + ); 9459 10960 self.inner.unary(req, path, codec).await 9460 10961 } 9461 10962 pub async fn sound_default( 9462 10963 &mut self, 9463 10964 request: impl tonic::IntoRequest<super::SoundDefaultRequest>, 9464 9464 - ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status> 9465 9465 - { 9466 9466 - self.inner.ready().await.map_err(|e| { 9467 9467 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 9468 9468 - })?; 10965 10965 + ) -> std::result::Result< 10966 10966 + tonic::Response<super::SoundDefaultResponse>, 10967 10967 + tonic::Status, 10968 10968 + > { 10969 10969 + self.inner 10970 10970 + .ready() 10971 10971 + .await 10972 10972 + .map_err(|e| { 10973 10973 + tonic::Status::unknown( 10974 10974 + format!("Service was not ready: {}", e.into()), 10975 10975 + ) 10976 10976 + })?; 9469 10977 let codec = tonic::codec::ProstCodec::default(); 9470 9470 - let path = 9471 9471 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundDefault"); 10978 10978 + let path = http::uri::PathAndQuery::from_static( 10979 10979 + "/rockbox.v1alpha1.SoundService/SoundDefault", 10980 10980 + ); 9472 10981 let mut req = request.into_request(); 9473 9473 - req.extensions_mut().insert(GrpcMethod::new( 9474 9474 - "rockbox.v1alpha1.SoundService", 9475 9475 - "SoundDefault", 9476 9476 - )); 10982 10982 + req.extensions_mut() 10983 10983 + .insert( 10984 10984 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundDefault"), 10985 10985 + ); 9477 10986 self.inner.unary(req, path, codec).await 9478 10987 } 9479 10988 pub async fn sound_min( 9480 10989 &mut self, 9481 10990 request: impl tonic::IntoRequest<super::SoundMinRequest>, 9482 9482 - ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status> { 9483 9483 - self.inner.ready().await.map_err(|e| { 9484 9484 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 9485 9485 - })?; 10991 10991 + ) -> std::result::Result< 10992 10992 + tonic::Response<super::SoundMinResponse>, 10993 10993 + tonic::Status, 10994 10994 + > { 10995 10995 + self.inner 10996 10996 + .ready() 10997 10997 + .await 10998 10998 + .map_err(|e| { 10999 10999 + tonic::Status::unknown( 11000 11000 + format!("Service was not ready: {}", e.into()), 11001 11001 + ) 11002 11002 + })?; 9486 11003 let codec = tonic::codec::ProstCodec::default(); 9487 9487 - let path = 9488 9488 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMin"); 11004 11004 + let path = http::uri::PathAndQuery::from_static( 11005 11005 + "/rockbox.v1alpha1.SoundService/SoundMin", 11006 11006 + ); 9489 11007 let mut req = request.into_request(); 9490 11008 req.extensions_mut() 9491 11009 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMin")); ··· 9494 11012 pub async fn sound_max( 9495 11013 &mut self, 9496 11014 request: impl tonic::IntoRequest<super::SoundMaxRequest>, 9497 9497 - ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status> { 9498 9498 - self.inner.ready().await.map_err(|e| { 9499 9499 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 9500 9500 - })?; 11015 11015 + ) -> std::result::Result< 11016 11016 + tonic::Response<super::SoundMaxResponse>, 11017 11017 + tonic::Status, 11018 11018 + > { 11019 11019 + self.inner 11020 11020 + .ready() 11021 11021 + .await 11022 11022 + .map_err(|e| { 11023 11023 + tonic::Status::unknown( 11024 11024 + format!("Service was not ready: {}", e.into()), 11025 11025 + ) 11026 11026 + })?; 9501 11027 let codec = tonic::codec::ProstCodec::default(); 9502 9502 - let path = 9503 9503 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMax"); 11028 11028 + let path = http::uri::PathAndQuery::from_static( 11029 11029 + "/rockbox.v1alpha1.SoundService/SoundMax", 11030 11030 + ); 9504 11031 let mut req = request.into_request(); 9505 11032 req.extensions_mut() 9506 11033 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMax")); ··· 9509 11036 pub async fn sound_unit( 9510 11037 &mut self, 9511 11038 request: impl tonic::IntoRequest<super::SoundUnitRequest>, 9512 9512 - ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status> { 9513 9513 - self.inner.ready().await.map_err(|e| { 9514 9514 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 9515 9515 - })?; 11039 11039 + ) -> std::result::Result< 11040 11040 + tonic::Response<super::SoundUnitResponse>, 11041 11041 + tonic::Status, 11042 11042 + > { 11043 11043 + self.inner 11044 11044 + .ready() 11045 11045 + .await 11046 11046 + .map_err(|e| { 11047 11047 + tonic::Status::unknown( 11048 11048 + format!("Service was not ready: {}", e.into()), 11049 11049 + ) 11050 11050 + })?; 9516 11051 let codec = tonic::codec::ProstCodec::default(); 9517 9517 - let path = 9518 9518 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundUnit"); 11052 11052 + let path = http::uri::PathAndQuery::from_static( 11053 11053 + "/rockbox.v1alpha1.SoundService/SoundUnit", 11054 11054 + ); 9519 11055 let mut req = request.into_request(); 9520 9520 - req.extensions_mut().insert(GrpcMethod::new( 9521 9521 - "rockbox.v1alpha1.SoundService", 9522 9522 - "SoundUnit", 9523 9523 - )); 11056 11056 + req.extensions_mut() 11057 11057 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundUnit")); 9524 11058 self.inner.unary(req, path, codec).await 9525 11059 } 9526 11060 pub async fn sound_val2_phys( 9527 11061 &mut self, 9528 11062 request: impl tonic::IntoRequest<super::SoundVal2PhysRequest>, 9529 9529 - ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status> 9530 9530 - { 9531 9531 - self.inner.ready().await.map_err(|e| { 9532 9532 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 9533 9533 - })?; 11063 11063 + ) -> std::result::Result< 11064 11064 + tonic::Response<super::SoundVal2PhysResponse>, 11065 11065 + tonic::Status, 11066 11066 + > { 11067 11067 + self.inner 11068 11068 + .ready() 11069 11069 + .await 11070 11070 + .map_err(|e| { 11071 11071 + tonic::Status::unknown( 11072 11072 + format!("Service was not ready: {}", e.into()), 11073 11073 + ) 11074 11074 + })?; 9534 11075 let codec = tonic::codec::ProstCodec::default(); 9535 11076 let path = http::uri::PathAndQuery::from_static( 9536 11077 "/rockbox.v1alpha1.SoundService/SoundVal2Phys", 9537 11078 ); 9538 11079 let mut req = request.into_request(); 9539 9539 - req.extensions_mut().insert(GrpcMethod::new( 9540 9540 - "rockbox.v1alpha1.SoundService", 9541 9541 - "SoundVal2Phys", 9542 9542 - )); 11080 11080 + req.extensions_mut() 11081 11081 + .insert( 11082 11082 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundVal2Phys"), 11083 11083 + ); 9543 11084 self.inner.unary(req, path, codec).await 9544 11085 } 9545 11086 pub async fn get_pitch( 9546 11087 &mut self, 9547 11088 request: impl tonic::IntoRequest<super::GetPitchRequest>, 9548 9548 - ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status> { 9549 9549 - self.inner.ready().await.map_err(|e| { 9550 9550 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 9551 9551 - })?; 11089 11089 + ) -> std::result::Result< 11090 11090 + tonic::Response<super::GetPitchResponse>, 11091 11091 + tonic::Status, 11092 11092 + > { 11093 11093 + self.inner 11094 11094 + .ready() 11095 11095 + .await 11096 11096 + .map_err(|e| { 11097 11097 + tonic::Status::unknown( 11098 11098 + format!("Service was not ready: {}", e.into()), 11099 11099 + ) 11100 11100 + })?; 9552 11101 let codec = tonic::codec::ProstCodec::default(); 9553 9553 - let path = 9554 9554 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/GetPitch"); 11102 11102 + let path = http::uri::PathAndQuery::from_static( 11103 11103 + "/rockbox.v1alpha1.SoundService/GetPitch", 11104 11104 + ); 9555 11105 let mut req = request.into_request(); 9556 11106 req.extensions_mut() 9557 11107 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "GetPitch")); ··· 9560 11110 pub async fn set_pitch( 9561 11111 &mut self, 9562 11112 request: impl tonic::IntoRequest<super::SetPitchRequest>, 9563 9563 - ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status> { 9564 9564 - self.inner.ready().await.map_err(|e| { 9565 9565 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 9566 9566 - })?; 11113 11113 + ) -> std::result::Result< 11114 11114 + tonic::Response<super::SetPitchResponse>, 11115 11115 + tonic::Status, 11116 11116 + > { 11117 11117 + self.inner 11118 11118 + .ready() 11119 11119 + .await 11120 11120 + .map_err(|e| { 11121 11121 + tonic::Status::unknown( 11122 11122 + format!("Service was not ready: {}", e.into()), 11123 11123 + ) 11124 11124 + })?; 9567 11125 let codec = tonic::codec::ProstCodec::default(); 9568 9568 - let path = 9569 9569 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SetPitch"); 11126 11126 + let path = http::uri::PathAndQuery::from_static( 11127 11127 + "/rockbox.v1alpha1.SoundService/SetPitch", 11128 11128 + ); 9570 11129 let mut req = request.into_request(); 9571 11130 req.extensions_mut() 9572 11131 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SetPitch")); ··· 9575 11134 pub async fn beep_play( 9576 11135 &mut self, 9577 11136 request: impl tonic::IntoRequest<super::BeepPlayRequest>, 9578 9578 - ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status> { 9579 9579 - self.inner.ready().await.map_err(|e| { 9580 9580 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 9581 9581 - })?; 11137 11137 + ) -> std::result::Result< 11138 11138 + tonic::Response<super::BeepPlayResponse>, 11139 11139 + tonic::Status, 11140 11140 + > { 11141 11141 + self.inner 11142 11142 + .ready() 11143 11143 + .await 11144 11144 + .map_err(|e| { 11145 11145 + tonic::Status::unknown( 11146 11146 + format!("Service was not ready: {}", e.into()), 11147 11147 + ) 11148 11148 + })?; 9582 11149 let codec = tonic::codec::ProstCodec::default(); 9583 9583 - let path = 9584 9584 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/BeepPlay"); 11150 11150 + let path = http::uri::PathAndQuery::from_static( 11151 11151 + "/rockbox.v1alpha1.SoundService/BeepPlay", 11152 11152 + ); 9585 11153 let mut req = request.into_request(); 9586 11154 req.extensions_mut() 9587 11155 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "BeepPlay")); ··· 9590 11158 pub async fn pcmbuf_fade( 9591 11159 &mut self, 9592 11160 request: impl tonic::IntoRequest<super::PcmbufFadeRequest>, 9593 9593 - ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status> 9594 9594 - { 9595 9595 - self.inner.ready().await.map_err(|e| { 9596 9596 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 9597 9597 - })?; 11161 11161 + ) -> std::result::Result< 11162 11162 + tonic::Response<super::PcmbufFadeResponse>, 11163 11163 + tonic::Status, 11164 11164 + > { 11165 11165 + self.inner 11166 11166 + .ready() 11167 11167 + .await 11168 11168 + .map_err(|e| { 11169 11169 + tonic::Status::unknown( 11170 11170 + format!("Service was not ready: {}", e.into()), 11171 11171 + ) 11172 11172 + })?; 9598 11173 let codec = tonic::codec::ProstCodec::default(); 9599 9599 - let path = 9600 9600 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/PcmbufFade"); 11174 11174 + let path = http::uri::PathAndQuery::from_static( 11175 11175 + "/rockbox.v1alpha1.SoundService/PcmbufFade", 11176 11176 + ); 9601 11177 let mut req = request.into_request(); 9602 9602 - req.extensions_mut().insert(GrpcMethod::new( 9603 9603 - "rockbox.v1alpha1.SoundService", 9604 9604 - "PcmbufFade", 9605 9605 - )); 11178 11178 + req.extensions_mut() 11179 11179 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "PcmbufFade")); 9606 11180 self.inner.unary(req, path, codec).await 9607 11181 } 9608 11182 pub async fn pcmbuf_set_low_latency( 9609 11183 &mut self, 9610 11184 request: impl tonic::IntoRequest<super::PcmbufSetLowLatencyRequest>, 9611 9611 - ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status> 9612 9612 - { 9613 9613 - self.inner.ready().await.map_err(|e| { 9614 9614 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 9615 9615 - })?; 11185 11185 + ) -> std::result::Result< 11186 11186 + tonic::Response<super::PcmbufSetLowLatencyResponse>, 11187 11187 + tonic::Status, 11188 11188 + > { 11189 11189 + self.inner 11190 11190 + .ready() 11191 11191 + .await 11192 11192 + .map_err(|e| { 11193 11193 + tonic::Status::unknown( 11194 11194 + format!("Service was not ready: {}", e.into()), 11195 11195 + ) 11196 11196 + })?; 9616 11197 let codec = tonic::codec::ProstCodec::default(); 9617 11198 let path = http::uri::PathAndQuery::from_static( 9618 11199 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency", 9619 11200 ); 9620 11201 let mut req = request.into_request(); 9621 9621 - req.extensions_mut().insert(GrpcMethod::new( 9622 9622 - "rockbox.v1alpha1.SoundService", 9623 9623 - "PcmbufSetLowLatency", 9624 9624 - )); 11202 11202 + req.extensions_mut() 11203 11203 + .insert( 11204 11204 + GrpcMethod::new( 11205 11205 + "rockbox.v1alpha1.SoundService", 11206 11206 + "PcmbufSetLowLatency", 11207 11207 + ), 11208 11208 + ); 9625 11209 self.inner.unary(req, path, codec).await 9626 11210 } 9627 11211 pub async fn system_sound_play( 9628 11212 &mut self, 9629 11213 request: impl tonic::IntoRequest<super::SystemSoundPlayRequest>, 9630 9630 - ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status> 9631 9631 - { 9632 9632 - self.inner.ready().await.map_err(|e| { 9633 9633 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 9634 9634 - })?; 11214 11214 + ) -> std::result::Result< 11215 11215 + tonic::Response<super::SystemSoundPlayResponse>, 11216 11216 + tonic::Status, 11217 11217 + > { 11218 11218 + self.inner 11219 11219 + .ready() 11220 11220 + .await 11221 11221 + .map_err(|e| { 11222 11222 + tonic::Status::unknown( 11223 11223 + format!("Service was not ready: {}", e.into()), 11224 11224 + ) 11225 11225 + })?; 9635 11226 let codec = tonic::codec::ProstCodec::default(); 9636 11227 let path = http::uri::PathAndQuery::from_static( 9637 11228 "/rockbox.v1alpha1.SoundService/SystemSoundPlay", 9638 11229 ); 9639 11230 let mut req = request.into_request(); 9640 9640 - req.extensions_mut().insert(GrpcMethod::new( 9641 9641 - "rockbox.v1alpha1.SoundService", 9642 9642 - "SystemSoundPlay", 9643 9643 - )); 11231 11231 + req.extensions_mut() 11232 11232 + .insert( 11233 11233 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SystemSoundPlay"), 11234 11234 + ); 9644 11235 self.inner.unary(req, path, codec).await 9645 11236 } 9646 11237 pub async fn keyclick_click( 9647 11238 &mut self, 9648 11239 request: impl tonic::IntoRequest<super::KeyclickClickRequest>, 9649 9649 - ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status> 9650 9650 - { 9651 9651 - self.inner.ready().await.map_err(|e| { 9652 9652 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 9653 9653 - })?; 11240 11240 + ) -> std::result::Result< 11241 11241 + tonic::Response<super::KeyclickClickResponse>, 11242 11242 + tonic::Status, 11243 11243 + > { 11244 11244 + self.inner 11245 11245 + .ready() 11246 11246 + .await 11247 11247 + .map_err(|e| { 11248 11248 + tonic::Status::unknown( 11249 11249 + format!("Service was not ready: {}", e.into()), 11250 11250 + ) 11251 11251 + })?; 9654 11252 let codec = tonic::codec::ProstCodec::default(); 9655 11253 let path = http::uri::PathAndQuery::from_static( 9656 11254 "/rockbox.v1alpha1.SoundService/KeyclickClick", 9657 11255 ); 9658 11256 let mut req = request.into_request(); 9659 9659 - req.extensions_mut().insert(GrpcMethod::new( 9660 9660 - "rockbox.v1alpha1.SoundService", 9661 9661 - "KeyclickClick", 9662 9662 - )); 11257 11257 + req.extensions_mut() 11258 11258 + .insert( 11259 11259 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "KeyclickClick"), 11260 11260 + ); 9663 11261 self.inner.unary(req, path, codec).await 9664 11262 } 9665 11263 } ··· 9671 11269 dead_code, 9672 11270 missing_docs, 9673 11271 clippy::wildcard_imports, 9674 9674 - clippy::let_unit_value 11272 11272 + clippy::let_unit_value, 9675 11273 )] 9676 11274 use tonic::codegen::*; 9677 11275 /// Generated trait containing gRPC methods that should be implemented for use with SoundServiceServer. ··· 9680 11278 async fn adjust_volume( 9681 11279 &self, 9682 11280 request: tonic::Request<super::AdjustVolumeRequest>, 9683 9683 - ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status>; 11281 11281 + ) -> std::result::Result< 11282 11282 + tonic::Response<super::AdjustVolumeResponse>, 11283 11283 + tonic::Status, 11284 11284 + >; 9684 11285 async fn sound_set( 9685 11286 &self, 9686 11287 request: tonic::Request<super::SoundSetRequest>, 9687 9687 - ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status>; 11288 11288 + ) -> std::result::Result< 11289 11289 + tonic::Response<super::SoundSetResponse>, 11290 11290 + tonic::Status, 11291 11291 + >; 9688 11292 async fn sound_current( 9689 11293 &self, 9690 11294 request: tonic::Request<super::SoundCurrentRequest>, 9691 9691 - ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status>; 11295 11295 + ) -> std::result::Result< 11296 11296 + tonic::Response<super::SoundCurrentResponse>, 11297 11297 + tonic::Status, 11298 11298 + >; 9692 11299 async fn sound_default( 9693 11300 &self, 9694 11301 request: tonic::Request<super::SoundDefaultRequest>, 9695 9695 - ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status>; 11302 11302 + ) -> std::result::Result< 11303 11303 + tonic::Response<super::SoundDefaultResponse>, 11304 11304 + tonic::Status, 11305 11305 + >; 9696 11306 async fn sound_min( 9697 11307 &self, 9698 11308 request: tonic::Request<super::SoundMinRequest>, 9699 9699 - ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status>; 11309 11309 + ) -> std::result::Result< 11310 11310 + tonic::Response<super::SoundMinResponse>, 11311 11311 + tonic::Status, 11312 11312 + >; 9700 11313 async fn sound_max( 9701 11314 &self, 9702 11315 request: tonic::Request<super::SoundMaxRequest>, 9703 9703 - ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status>; 11316 11316 + ) -> std::result::Result< 11317 11317 + tonic::Response<super::SoundMaxResponse>, 11318 11318 + tonic::Status, 11319 11319 + >; 9704 11320 async fn sound_unit( 9705 11321 &self, 9706 11322 request: tonic::Request<super::SoundUnitRequest>, 9707 9707 - ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status>; 11323 11323 + ) -> std::result::Result< 11324 11324 + tonic::Response<super::SoundUnitResponse>, 11325 11325 + tonic::Status, 11326 11326 + >; 9708 11327 async fn sound_val2_phys( 9709 11328 &self, 9710 11329 request: tonic::Request<super::SoundVal2PhysRequest>, 9711 9711 - ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status>; 11330 11330 + ) -> std::result::Result< 11331 11331 + tonic::Response<super::SoundVal2PhysResponse>, 11332 11332 + tonic::Status, 11333 11333 + >; 9712 11334 async fn get_pitch( 9713 11335 &self, 9714 11336 request: tonic::Request<super::GetPitchRequest>, 9715 9715 - ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status>; 11337 11337 + ) -> std::result::Result< 11338 11338 + tonic::Response<super::GetPitchResponse>, 11339 11339 + tonic::Status, 11340 11340 + >; 9716 11341 async fn set_pitch( 9717 11342 &self, 9718 11343 request: tonic::Request<super::SetPitchRequest>, 9719 9719 - ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status>; 11344 11344 + ) -> std::result::Result< 11345 11345 + tonic::Response<super::SetPitchResponse>, 11346 11346 + tonic::Status, 11347 11347 + >; 9720 11348 async fn beep_play( 9721 11349 &self, 9722 11350 request: tonic::Request<super::BeepPlayRequest>, 9723 9723 - ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status>; 11351 11351 + ) -> std::result::Result< 11352 11352 + tonic::Response<super::BeepPlayResponse>, 11353 11353 + tonic::Status, 11354 11354 + >; 9724 11355 async fn pcmbuf_fade( 9725 11356 &self, 9726 11357 request: tonic::Request<super::PcmbufFadeRequest>, 9727 9727 - ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status>; 11358 11358 + ) -> std::result::Result< 11359 11359 + tonic::Response<super::PcmbufFadeResponse>, 11360 11360 + tonic::Status, 11361 11361 + >; 9728 11362 async fn pcmbuf_set_low_latency( 9729 11363 &self, 9730 11364 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 9731 9731 - ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status>; 11365 11365 + ) -> std::result::Result< 11366 11366 + tonic::Response<super::PcmbufSetLowLatencyResponse>, 11367 11367 + tonic::Status, 11368 11368 + >; 9732 11369 async fn system_sound_play( 9733 11370 &self, 9734 11371 request: tonic::Request<super::SystemSoundPlayRequest>, 9735 9735 - ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status>; 11372 11372 + ) -> std::result::Result< 11373 11373 + tonic::Response<super::SystemSoundPlayResponse>, 11374 11374 + tonic::Status, 11375 11375 + >; 9736 11376 async fn keyclick_click( 9737 11377 &self, 9738 11378 request: tonic::Request<super::KeyclickClickRequest>, 9739 9739 - ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>; 11379 11379 + ) -> std::result::Result< 11380 11380 + tonic::Response<super::KeyclickClickResponse>, 11381 11381 + tonic::Status, 11382 11382 + >; 9740 11383 } 9741 11384 #[derive(Debug)] 9742 11385 pub struct SoundServiceServer<T> { ··· 9759 11402 max_encoding_message_size: None, 9760 11403 } 9761 11404 } 9762 9762 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 11405 11405 + pub fn with_interceptor<F>( 11406 11406 + inner: T, 11407 11407 + interceptor: F, 11408 11408 + ) -> InterceptedService<Self, F> 9763 11409 where 9764 11410 F: tonic::service::Interceptor, 9765 11411 { ··· 9814 11460 "/rockbox.v1alpha1.SoundService/AdjustVolume" => { 9815 11461 #[allow(non_camel_case_types)] 9816 11462 struct AdjustVolumeSvc<T: SoundService>(pub Arc<T>); 9817 9817 - impl<T: SoundService> tonic::server::UnaryService<super::AdjustVolumeRequest> 9818 9818 - for AdjustVolumeSvc<T> 9819 9819 - { 11463 11463 + impl< 11464 11464 + T: SoundService, 11465 11465 + > tonic::server::UnaryService<super::AdjustVolumeRequest> 11466 11466 + for AdjustVolumeSvc<T> { 9820 11467 type Response = super::AdjustVolumeResponse; 9821 9821 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 11468 11468 + type Future = BoxFuture< 11469 11469 + tonic::Response<Self::Response>, 11470 11470 + tonic::Status, 11471 11471 + >; 9822 11472 fn call( 9823 11473 &mut self, 9824 11474 request: tonic::Request<super::AdjustVolumeRequest>, ··· 9855 11505 "/rockbox.v1alpha1.SoundService/SoundSet" => { 9856 11506 #[allow(non_camel_case_types)] 9857 11507 struct SoundSetSvc<T: SoundService>(pub Arc<T>); 9858 9858 - impl<T: SoundService> tonic::server::UnaryService<super::SoundSetRequest> for SoundSetSvc<T> { 11508 11508 + impl< 11509 11509 + T: SoundService, 11510 11510 + > tonic::server::UnaryService<super::SoundSetRequest> 11511 11511 + for SoundSetSvc<T> { 9859 11512 type Response = super::SoundSetResponse; 9860 9860 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 11513 11513 + type Future = BoxFuture< 11514 11514 + tonic::Response<Self::Response>, 11515 11515 + tonic::Status, 11516 11516 + >; 9861 11517 fn call( 9862 11518 &mut self, 9863 11519 request: tonic::Request<super::SoundSetRequest>, ··· 9894 11550 "/rockbox.v1alpha1.SoundService/SoundCurrent" => { 9895 11551 #[allow(non_camel_case_types)] 9896 11552 struct SoundCurrentSvc<T: SoundService>(pub Arc<T>); 9897 9897 - impl<T: SoundService> tonic::server::UnaryService<super::SoundCurrentRequest> 9898 9898 - for SoundCurrentSvc<T> 9899 9899 - { 11553 11553 + impl< 11554 11554 + T: SoundService, 11555 11555 + > tonic::server::UnaryService<super::SoundCurrentRequest> 11556 11556 + for SoundCurrentSvc<T> { 9900 11557 type Response = super::SoundCurrentResponse; 9901 9901 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 11558 11558 + type Future = BoxFuture< 11559 11559 + tonic::Response<Self::Response>, 11560 11560 + tonic::Status, 11561 11561 + >; 9902 11562 fn call( 9903 11563 &mut self, 9904 11564 request: tonic::Request<super::SoundCurrentRequest>, ··· 9935 11595 "/rockbox.v1alpha1.SoundService/SoundDefault" => { 9936 11596 #[allow(non_camel_case_types)] 9937 11597 struct SoundDefaultSvc<T: SoundService>(pub Arc<T>); 9938 9938 - impl<T: SoundService> tonic::server::UnaryService<super::SoundDefaultRequest> 9939 9939 - for SoundDefaultSvc<T> 9940 9940 - { 11598 11598 + impl< 11599 11599 + T: SoundService, 11600 11600 + > tonic::server::UnaryService<super::SoundDefaultRequest> 11601 11601 + for SoundDefaultSvc<T> { 9941 11602 type Response = super::SoundDefaultResponse; 9942 9942 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 11603 11603 + type Future = BoxFuture< 11604 11604 + tonic::Response<Self::Response>, 11605 11605 + tonic::Status, 11606 11606 + >; 9943 11607 fn call( 9944 11608 &mut self, 9945 11609 request: tonic::Request<super::SoundDefaultRequest>, ··· 9976 11640 "/rockbox.v1alpha1.SoundService/SoundMin" => { 9977 11641 #[allow(non_camel_case_types)] 9978 11642 struct SoundMinSvc<T: SoundService>(pub Arc<T>); 9979 9979 - impl<T: SoundService> tonic::server::UnaryService<super::SoundMinRequest> for SoundMinSvc<T> { 11643 11643 + impl< 11644 11644 + T: SoundService, 11645 11645 + > tonic::server::UnaryService<super::SoundMinRequest> 11646 11646 + for SoundMinSvc<T> { 9980 11647 type Response = super::SoundMinResponse; 9981 9981 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 11648 11648 + type Future = BoxFuture< 11649 11649 + tonic::Response<Self::Response>, 11650 11650 + tonic::Status, 11651 11651 + >; 9982 11652 fn call( 9983 11653 &mut self, 9984 11654 request: tonic::Request<super::SoundMinRequest>, ··· 10015 11685 "/rockbox.v1alpha1.SoundService/SoundMax" => { 10016 11686 #[allow(non_camel_case_types)] 10017 11687 struct SoundMaxSvc<T: SoundService>(pub Arc<T>); 10018 10018 - impl<T: SoundService> tonic::server::UnaryService<super::SoundMaxRequest> for SoundMaxSvc<T> { 11688 11688 + impl< 11689 11689 + T: SoundService, 11690 11690 + > tonic::server::UnaryService<super::SoundMaxRequest> 11691 11691 + for SoundMaxSvc<T> { 10019 11692 type Response = super::SoundMaxResponse; 10020 10020 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 11693 11693 + type Future = BoxFuture< 11694 11694 + tonic::Response<Self::Response>, 11695 11695 + tonic::Status, 11696 11696 + >; 10021 11697 fn call( 10022 11698 &mut self, 10023 11699 request: tonic::Request<super::SoundMaxRequest>, ··· 10054 11730 "/rockbox.v1alpha1.SoundService/SoundUnit" => { 10055 11731 #[allow(non_camel_case_types)] 10056 11732 struct SoundUnitSvc<T: SoundService>(pub Arc<T>); 10057 10057 - impl<T: SoundService> tonic::server::UnaryService<super::SoundUnitRequest> for SoundUnitSvc<T> { 11733 11733 + impl< 11734 11734 + T: SoundService, 11735 11735 + > tonic::server::UnaryService<super::SoundUnitRequest> 11736 11736 + for SoundUnitSvc<T> { 10058 11737 type Response = super::SoundUnitResponse; 10059 10059 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 11738 11738 + type Future = BoxFuture< 11739 11739 + tonic::Response<Self::Response>, 11740 11740 + tonic::Status, 11741 11741 + >; 10060 11742 fn call( 10061 11743 &mut self, 10062 11744 request: tonic::Request<super::SoundUnitRequest>, ··· 10093 11775 "/rockbox.v1alpha1.SoundService/SoundVal2Phys" => { 10094 11776 #[allow(non_camel_case_types)] 10095 11777 struct SoundVal2PhysSvc<T: SoundService>(pub Arc<T>); 10096 10096 - impl<T: SoundService> tonic::server::UnaryService<super::SoundVal2PhysRequest> 10097 10097 - for SoundVal2PhysSvc<T> 10098 10098 - { 11778 11778 + impl< 11779 11779 + T: SoundService, 11780 11780 + > tonic::server::UnaryService<super::SoundVal2PhysRequest> 11781 11781 + for SoundVal2PhysSvc<T> { 10099 11782 type Response = super::SoundVal2PhysResponse; 10100 10100 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 11783 11783 + type Future = BoxFuture< 11784 11784 + tonic::Response<Self::Response>, 11785 11785 + tonic::Status, 11786 11786 + >; 10101 11787 fn call( 10102 11788 &mut self, 10103 11789 request: tonic::Request<super::SoundVal2PhysRequest>, ··· 10134 11820 "/rockbox.v1alpha1.SoundService/GetPitch" => { 10135 11821 #[allow(non_camel_case_types)] 10136 11822 struct GetPitchSvc<T: SoundService>(pub Arc<T>); 10137 10137 - impl<T: SoundService> tonic::server::UnaryService<super::GetPitchRequest> for GetPitchSvc<T> { 11823 11823 + impl< 11824 11824 + T: SoundService, 11825 11825 + > tonic::server::UnaryService<super::GetPitchRequest> 11826 11826 + for GetPitchSvc<T> { 10138 11827 type Response = super::GetPitchResponse; 10139 10139 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 11828 11828 + type Future = BoxFuture< 11829 11829 + tonic::Response<Self::Response>, 11830 11830 + tonic::Status, 11831 11831 + >; 10140 11832 fn call( 10141 11833 &mut self, 10142 11834 request: tonic::Request<super::GetPitchRequest>, ··· 10173 11865 "/rockbox.v1alpha1.SoundService/SetPitch" => { 10174 11866 #[allow(non_camel_case_types)] 10175 11867 struct SetPitchSvc<T: SoundService>(pub Arc<T>); 10176 10176 - impl<T: SoundService> tonic::server::UnaryService<super::SetPitchRequest> for SetPitchSvc<T> { 11868 11868 + impl< 11869 11869 + T: SoundService, 11870 11870 + > tonic::server::UnaryService<super::SetPitchRequest> 11871 11871 + for SetPitchSvc<T> { 10177 11872 type Response = super::SetPitchResponse; 10178 10178 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 11873 11873 + type Future = BoxFuture< 11874 11874 + tonic::Response<Self::Response>, 11875 11875 + tonic::Status, 11876 11876 + >; 10179 11877 fn call( 10180 11878 &mut self, 10181 11879 request: tonic::Request<super::SetPitchRequest>, ··· 10212 11910 "/rockbox.v1alpha1.SoundService/BeepPlay" => { 10213 11911 #[allow(non_camel_case_types)] 10214 11912 struct BeepPlaySvc<T: SoundService>(pub Arc<T>); 10215 10215 - impl<T: SoundService> tonic::server::UnaryService<super::BeepPlayRequest> for BeepPlaySvc<T> { 11913 11913 + impl< 11914 11914 + T: SoundService, 11915 11915 + > tonic::server::UnaryService<super::BeepPlayRequest> 11916 11916 + for BeepPlaySvc<T> { 10216 11917 type Response = super::BeepPlayResponse; 10217 10217 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 11918 11918 + type Future = BoxFuture< 11919 11919 + tonic::Response<Self::Response>, 11920 11920 + tonic::Status, 11921 11921 + >; 10218 11922 fn call( 10219 11923 &mut self, 10220 11924 request: tonic::Request<super::BeepPlayRequest>, ··· 10251 11955 "/rockbox.v1alpha1.SoundService/PcmbufFade" => { 10252 11956 #[allow(non_camel_case_types)] 10253 11957 struct PcmbufFadeSvc<T: SoundService>(pub Arc<T>); 10254 10254 - impl<T: SoundService> tonic::server::UnaryService<super::PcmbufFadeRequest> for PcmbufFadeSvc<T> { 11958 11958 + impl< 11959 11959 + T: SoundService, 11960 11960 + > tonic::server::UnaryService<super::PcmbufFadeRequest> 11961 11961 + for PcmbufFadeSvc<T> { 10255 11962 type Response = super::PcmbufFadeResponse; 10256 10256 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 11963 11963 + type Future = BoxFuture< 11964 11964 + tonic::Response<Self::Response>, 11965 11965 + tonic::Status, 11966 11966 + >; 10257 11967 fn call( 10258 11968 &mut self, 10259 11969 request: tonic::Request<super::PcmbufFadeRequest>, ··· 10290 12000 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency" => { 10291 12001 #[allow(non_camel_case_types)] 10292 12002 struct PcmbufSetLowLatencySvc<T: SoundService>(pub Arc<T>); 10293 10293 - impl<T: SoundService> 10294 10294 - tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 10295 10295 - for PcmbufSetLowLatencySvc<T> 10296 10296 - { 12003 12003 + impl< 12004 12004 + T: SoundService, 12005 12005 + > tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 12006 12006 + for PcmbufSetLowLatencySvc<T> { 10297 12007 type Response = super::PcmbufSetLowLatencyResponse; 10298 10298 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 12008 12008 + type Future = BoxFuture< 12009 12009 + tonic::Response<Self::Response>, 12010 12010 + tonic::Status, 12011 12011 + >; 10299 12012 fn call( 10300 12013 &mut self, 10301 12014 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 10302 12015 ) -> Self::Future { 10303 12016 let inner = Arc::clone(&self.0); 10304 12017 let fut = async move { 10305 10305 - <T as SoundService>::pcmbuf_set_low_latency(&inner, request).await 12018 12018 + <T as SoundService>::pcmbuf_set_low_latency(&inner, request) 12019 12019 + .await 10306 12020 }; 10307 12021 Box::pin(fut) 10308 12022 } ··· 10332 12046 "/rockbox.v1alpha1.SoundService/SystemSoundPlay" => { 10333 12047 #[allow(non_camel_case_types)] 10334 12048 struct SystemSoundPlaySvc<T: SoundService>(pub Arc<T>); 10335 10335 - impl<T: SoundService> tonic::server::UnaryService<super::SystemSoundPlayRequest> 10336 10336 - for SystemSoundPlaySvc<T> 10337 10337 - { 12049 12049 + impl< 12050 12050 + T: SoundService, 12051 12051 + > tonic::server::UnaryService<super::SystemSoundPlayRequest> 12052 12052 + for SystemSoundPlaySvc<T> { 10338 12053 type Response = super::SystemSoundPlayResponse; 10339 10339 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 12054 12054 + type Future = BoxFuture< 12055 12055 + tonic::Response<Self::Response>, 12056 12056 + tonic::Status, 12057 12057 + >; 10340 12058 fn call( 10341 12059 &mut self, 10342 12060 request: tonic::Request<super::SystemSoundPlayRequest>, 10343 12061 ) -> Self::Future { 10344 12062 let inner = Arc::clone(&self.0); 10345 12063 let fut = async move { 10346 10346 - <T as SoundService>::system_sound_play(&inner, request).await 12064 12064 + <T as SoundService>::system_sound_play(&inner, request) 12065 12065 + .await 10347 12066 }; 10348 12067 Box::pin(fut) 10349 12068 } ··· 10373 12092 "/rockbox.v1alpha1.SoundService/KeyclickClick" => { 10374 12093 #[allow(non_camel_case_types)] 10375 12094 struct KeyclickClickSvc<T: SoundService>(pub Arc<T>); 10376 10376 - impl<T: SoundService> tonic::server::UnaryService<super::KeyclickClickRequest> 10377 10377 - for KeyclickClickSvc<T> 10378 10378 - { 12095 12095 + impl< 12096 12096 + T: SoundService, 12097 12097 + > tonic::server::UnaryService<super::KeyclickClickRequest> 12098 12098 + for KeyclickClickSvc<T> { 10379 12099 type Response = super::KeyclickClickResponse; 10380 10380 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 12100 12100 + type Future = BoxFuture< 12101 12101 + tonic::Response<Self::Response>, 12102 12102 + tonic::Status, 12103 12103 + >; 10381 12104 fn call( 10382 12105 &mut self, 10383 12106 request: tonic::Request<super::KeyclickClickRequest>, ··· 10411 12134 }; 10412 12135 Box::pin(fut) 10413 12136 } 10414 10414 - _ => Box::pin(async move { 10415 10415 - let mut response = http::Response::new(empty_body()); 10416 10416 - let headers = response.headers_mut(); 10417 10417 - headers.insert( 10418 10418 - tonic::Status::GRPC_STATUS, 10419 10419 - (tonic::Code::Unimplemented as i32).into(), 10420 10420 - ); 10421 10421 - headers.insert( 10422 10422 - http::header::CONTENT_TYPE, 10423 10423 - tonic::metadata::GRPC_CONTENT_TYPE, 10424 10424 - ); 10425 10425 - Ok(response) 10426 10426 - }), 12137 12137 + _ => { 12138 12138 + Box::pin(async move { 12139 12139 + let mut response = http::Response::new(empty_body()); 12140 12140 + let headers = response.headers_mut(); 12141 12141 + headers 12142 12142 + .insert( 12143 12143 + tonic::Status::GRPC_STATUS, 12144 12144 + (tonic::Code::Unimplemented as i32).into(), 12145 12145 + ); 12146 12146 + headers 12147 12147 + .insert( 12148 12148 + http::header::CONTENT_TYPE, 12149 12149 + tonic::metadata::GRPC_CONTENT_TYPE, 12150 12150 + ); 12151 12151 + Ok(response) 12152 12152 + }) 12153 12153 + } 10427 12154 } 10428 12155 } 10429 12156 } ··· 10484 12211 dead_code, 10485 12212 missing_docs, 10486 12213 clippy::wildcard_imports, 10487 10487 - clippy::let_unit_value 12214 12214 + clippy::let_unit_value, 10488 12215 )] 10489 10489 - use tonic::codegen::http::Uri; 10490 12216 use tonic::codegen::*; 12217 12217 + use tonic::codegen::http::Uri; 10491 12218 #[derive(Debug, Clone)] 10492 12219 pub struct SystemServiceClient<T> { 10493 12220 inner: tonic::client::Grpc<T>, ··· 10531 12258 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 10532 12259 >, 10533 12260 >, 10534 10534 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 10535 10535 - Into<StdError> + std::marker::Send + std::marker::Sync, 12261 12261 + <T as tonic::codegen::Service< 12262 12262 + http::Request<tonic::body::BoxBody>, 12263 12263 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 10536 12264 { 10537 12265 SystemServiceClient::new(InterceptedService::new(inner, interceptor)) 10538 12266 } ··· 10570 12298 pub async fn get_rockbox_version( 10571 12299 &mut self, 10572 12300 request: impl tonic::IntoRequest<super::GetRockboxVersionRequest>, 10573 10573 - ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status> 10574 10574 - { 10575 10575 - self.inner.ready().await.map_err(|e| { 10576 10576 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 10577 10577 - })?; 12301 12301 + ) -> std::result::Result< 12302 12302 + tonic::Response<super::GetRockboxVersionResponse>, 12303 12303 + tonic::Status, 12304 12304 + > { 12305 12305 + self.inner 12306 12306 + .ready() 12307 12307 + .await 12308 12308 + .map_err(|e| { 12309 12309 + tonic::Status::unknown( 12310 12310 + format!("Service was not ready: {}", e.into()), 12311 12311 + ) 12312 12312 + })?; 10578 12313 let codec = tonic::codec::ProstCodec::default(); 10579 12314 let path = http::uri::PathAndQuery::from_static( 10580 12315 "/rockbox.v1alpha1.SystemService/GetRockboxVersion", 10581 12316 ); 10582 12317 let mut req = request.into_request(); 10583 10583 - req.extensions_mut().insert(GrpcMethod::new( 10584 10584 - "rockbox.v1alpha1.SystemService", 10585 10585 - "GetRockboxVersion", 10586 10586 - )); 12318 12318 + req.extensions_mut() 12319 12319 + .insert( 12320 12320 + GrpcMethod::new( 12321 12321 + "rockbox.v1alpha1.SystemService", 12322 12322 + "GetRockboxVersion", 12323 12323 + ), 12324 12324 + ); 10587 12325 self.inner.unary(req, path, codec).await 10588 12326 } 10589 12327 pub async fn get_global_status( 10590 12328 &mut self, 10591 12329 request: impl tonic::IntoRequest<super::GetGlobalStatusRequest>, 10592 10592 - ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status> 10593 10593 - { 10594 10594 - self.inner.ready().await.map_err(|e| { 10595 10595 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 10596 10596 - })?; 12330 12330 + ) -> std::result::Result< 12331 12331 + tonic::Response<super::GetGlobalStatusResponse>, 12332 12332 + tonic::Status, 12333 12333 + > { 12334 12334 + self.inner 12335 12335 + .ready() 12336 12336 + .await 12337 12337 + .map_err(|e| { 12338 12338 + tonic::Status::unknown( 12339 12339 + format!("Service was not ready: {}", e.into()), 12340 12340 + ) 12341 12341 + })?; 10597 12342 let codec = tonic::codec::ProstCodec::default(); 10598 12343 let path = http::uri::PathAndQuery::from_static( 10599 12344 "/rockbox.v1alpha1.SystemService/GetGlobalStatus", 10600 12345 ); 10601 12346 let mut req = request.into_request(); 10602 10602 - req.extensions_mut().insert(GrpcMethod::new( 10603 10603 - "rockbox.v1alpha1.SystemService", 10604 10604 - "GetGlobalStatus", 10605 10605 - )); 12347 12347 + req.extensions_mut() 12348 12348 + .insert( 12349 12349 + GrpcMethod::new("rockbox.v1alpha1.SystemService", "GetGlobalStatus"), 12350 12350 + ); 10606 12351 self.inner.unary(req, path, codec).await 10607 12352 } 10608 12353 } ··· 10614 12359 dead_code, 10615 12360 missing_docs, 10616 12361 clippy::wildcard_imports, 10617 10617 - clippy::let_unit_value 12362 12362 + clippy::let_unit_value, 10618 12363 )] 10619 12364 use tonic::codegen::*; 10620 12365 /// Generated trait containing gRPC methods that should be implemented for use with SystemServiceServer. ··· 10623 12368 async fn get_rockbox_version( 10624 12369 &self, 10625 12370 request: tonic::Request<super::GetRockboxVersionRequest>, 10626 10626 - ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status>; 12371 12371 + ) -> std::result::Result< 12372 12372 + tonic::Response<super::GetRockboxVersionResponse>, 12373 12373 + tonic::Status, 12374 12374 + >; 10627 12375 async fn get_global_status( 10628 12376 &self, 10629 12377 request: tonic::Request<super::GetGlobalStatusRequest>, 10630 10630 - ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>; 12378 12378 + ) -> std::result::Result< 12379 12379 + tonic::Response<super::GetGlobalStatusResponse>, 12380 12380 + tonic::Status, 12381 12381 + >; 10631 12382 } 10632 12383 #[derive(Debug)] 10633 12384 pub struct SystemServiceServer<T> { ··· 10650 12401 max_encoding_message_size: None, 10651 12402 } 10652 12403 } 10653 10653 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 12404 12404 + pub fn with_interceptor<F>( 12405 12405 + inner: T, 12406 12406 + interceptor: F, 12407 12407 + ) -> InterceptedService<Self, F> 10654 12408 where 10655 12409 F: tonic::service::Interceptor, 10656 12410 { ··· 10705 12459 "/rockbox.v1alpha1.SystemService/GetRockboxVersion" => { 10706 12460 #[allow(non_camel_case_types)] 10707 12461 struct GetRockboxVersionSvc<T: SystemService>(pub Arc<T>); 10708 10708 - impl<T: SystemService> 10709 10709 - tonic::server::UnaryService<super::GetRockboxVersionRequest> 10710 10710 - for GetRockboxVersionSvc<T> 10711 10711 - { 12462 12462 + impl< 12463 12463 + T: SystemService, 12464 12464 + > tonic::server::UnaryService<super::GetRockboxVersionRequest> 12465 12465 + for GetRockboxVersionSvc<T> { 10712 12466 type Response = super::GetRockboxVersionResponse; 10713 10713 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 12467 12467 + type Future = BoxFuture< 12468 12468 + tonic::Response<Self::Response>, 12469 12469 + tonic::Status, 12470 12470 + >; 10714 12471 fn call( 10715 12472 &mut self, 10716 12473 request: tonic::Request<super::GetRockboxVersionRequest>, 10717 12474 ) -> Self::Future { 10718 12475 let inner = Arc::clone(&self.0); 10719 12476 let fut = async move { 10720 10720 - <T as SystemService>::get_rockbox_version(&inner, request).await 12477 12477 + <T as SystemService>::get_rockbox_version(&inner, request) 12478 12478 + .await 10721 12479 }; 10722 12480 Box::pin(fut) 10723 12481 } ··· 10747 12505 "/rockbox.v1alpha1.SystemService/GetGlobalStatus" => { 10748 12506 #[allow(non_camel_case_types)] 10749 12507 struct GetGlobalStatusSvc<T: SystemService>(pub Arc<T>); 10750 10750 - impl<T: SystemService> 10751 10751 - tonic::server::UnaryService<super::GetGlobalStatusRequest> 10752 10752 - for GetGlobalStatusSvc<T> 10753 10753 - { 12508 12508 + impl< 12509 12509 + T: SystemService, 12510 12510 + > tonic::server::UnaryService<super::GetGlobalStatusRequest> 12511 12511 + for GetGlobalStatusSvc<T> { 10754 12512 type Response = super::GetGlobalStatusResponse; 10755 10755 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 12513 12513 + type Future = BoxFuture< 12514 12514 + tonic::Response<Self::Response>, 12515 12515 + tonic::Status, 12516 12516 + >; 10756 12517 fn call( 10757 12518 &mut self, 10758 12519 request: tonic::Request<super::GetGlobalStatusRequest>, 10759 12520 ) -> Self::Future { 10760 12521 let inner = Arc::clone(&self.0); 10761 12522 let fut = async move { 10762 10762 - <T as SystemService>::get_global_status(&inner, request).await 12523 12523 + <T as SystemService>::get_global_status(&inner, request) 12524 12524 + .await 10763 12525 }; 10764 12526 Box::pin(fut) 10765 12527 } ··· 10786 12548 }; 10787 12549 Box::pin(fut) 10788 12550 } 10789 10789 - _ => Box::pin(async move { 10790 10790 - let mut response = http::Response::new(empty_body()); 10791 10791 - let headers = response.headers_mut(); 10792 10792 - headers.insert( 10793 10793 - tonic::Status::GRPC_STATUS, 10794 10794 - (tonic::Code::Unimplemented as i32).into(), 10795 10795 - ); 10796 10796 - headers.insert( 10797 10797 - http::header::CONTENT_TYPE, 10798 10798 - tonic::metadata::GRPC_CONTENT_TYPE, 10799 10799 - ); 10800 10800 - Ok(response) 10801 10801 - }), 12551 12551 + _ => { 12552 12552 + Box::pin(async move { 12553 12553 + let mut response = http::Response::new(empty_body()); 12554 12554 + let headers = response.headers_mut(); 12555 12555 + headers 12556 12556 + .insert( 12557 12557 + tonic::Status::GRPC_STATUS, 12558 12558 + (tonic::Code::Unimplemented as i32).into(), 12559 12559 + ); 12560 12560 + headers 12561 12561 + .insert( 12562 12562 + http::header::CONTENT_TYPE, 12563 12563 + tonic::metadata::GRPC_CONTENT_TYPE, 12564 12564 + ); 12565 12565 + Ok(response) 12566 12566 + }) 12567 12567 + } 10802 12568 } 10803 12569 } 10804 12570 }

+4 -4

tools/root.make

reviewed

··· 457 457 458 458 zig: lib 459 459 cd .. \ 460 460 - && cargo build -p rockbox-cli --release \ 461 461 - && cargo build -p rockbox-server --release \ 462 462 - && cargo build -p rockbox --release \ 463 463 - && cd zig && zig build 460 460 + && cargo build --locked -p rockbox-cli --release \ 461 461 + && cargo build --locked -p rockbox-server --release \ 462 462 + && cargo build --locked -p rockbox --release \ 463 463 + && cd zig && zig build 464 464 help: 465 465 @echo "A few helpful make targets" 466 466 @echo ""