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