utxorpc_spec/
utxorpc.v1beta.query.tonic.rs

1// @generated
2/// Generated client implementations.
3pub mod query_service_client {
4    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
5    use tonic::codegen::*;
6    use tonic::codegen::http::Uri;
7    /** Service definition for querying the state of the chain.
8*/
9    #[derive(Debug, Clone)]
10    pub struct QueryServiceClient<T> {
11        inner: tonic::client::Grpc<T>,
12    }
13    impl<T> QueryServiceClient<T>
14    where
15        T: tonic::client::GrpcService<tonic::body::BoxBody>,
16        T::Error: Into<StdError>,
17        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
18        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
19    {
20        pub fn new(inner: T) -> Self {
21            let inner = tonic::client::Grpc::new(inner);
22            Self { inner }
23        }
24        pub fn with_origin(inner: T, origin: Uri) -> Self {
25            let inner = tonic::client::Grpc::with_origin(inner, origin);
26            Self { inner }
27        }
28        pub fn with_interceptor<F>(
29            inner: T,
30            interceptor: F,
31        ) -> QueryServiceClient<InterceptedService<T, F>>
32        where
33            F: tonic::service::Interceptor,
34            T::ResponseBody: Default,
35            T: tonic::codegen::Service<
36                http::Request<tonic::body::BoxBody>,
37                Response = http::Response<
38                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
39                >,
40            >,
41            <T as tonic::codegen::Service<
42                http::Request<tonic::body::BoxBody>,
43            >>::Error: Into<StdError> + Send + Sync,
44        {
45            QueryServiceClient::new(InterceptedService::new(inner, interceptor))
46        }
47        /// Compress requests with the given encoding.
48        ///
49        /// This requires the server to support it otherwise it might respond with an
50        /// error.
51        #[must_use]
52        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
53            self.inner = self.inner.send_compressed(encoding);
54            self
55        }
56        /// Enable decompressing responses.
57        #[must_use]
58        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
59            self.inner = self.inner.accept_compressed(encoding);
60            self
61        }
62        /// Limits the maximum size of a decoded message.
63        ///
64        /// Default: `4MB`
65        #[must_use]
66        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
67            self.inner = self.inner.max_decoding_message_size(limit);
68            self
69        }
70        /// Limits the maximum size of an encoded message.
71        ///
72        /// Default: `usize::MAX`
73        #[must_use]
74        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
75            self.inner = self.inner.max_encoding_message_size(limit);
76            self
77        }
78        ///
79        pub async fn read_params(
80            &mut self,
81            request: impl tonic::IntoRequest<super::ReadParamsRequest>,
82        ) -> std::result::Result<
83            tonic::Response<super::ReadParamsResponse>,
84            tonic::Status,
85        > {
86            self.inner
87                .ready()
88                .await
89                .map_err(|e| {
90                    tonic::Status::new(
91                        tonic::Code::Unknown,
92                        format!("Service was not ready: {}", e.into()),
93                    )
94                })?;
95            let codec = tonic::codec::ProstCodec::default();
96            let path = http::uri::PathAndQuery::from_static(
97                "/utxorpc.v1beta.query.QueryService/ReadParams",
98            );
99            let mut req = request.into_request();
100            req.extensions_mut()
101                .insert(
102                    GrpcMethod::new("utxorpc.v1beta.query.QueryService", "ReadParams"),
103                );
104            self.inner.unary(req, path, codec).await
105        }
106        ///
107        pub async fn read_utxos(
108            &mut self,
109            request: impl tonic::IntoRequest<super::ReadUtxosRequest>,
110        ) -> std::result::Result<
111            tonic::Response<super::ReadUtxosResponse>,
112            tonic::Status,
113        > {
114            self.inner
115                .ready()
116                .await
117                .map_err(|e| {
118                    tonic::Status::new(
119                        tonic::Code::Unknown,
120                        format!("Service was not ready: {}", e.into()),
121                    )
122                })?;
123            let codec = tonic::codec::ProstCodec::default();
124            let path = http::uri::PathAndQuery::from_static(
125                "/utxorpc.v1beta.query.QueryService/ReadUtxos",
126            );
127            let mut req = request.into_request();
128            req.extensions_mut()
129                .insert(
130                    GrpcMethod::new("utxorpc.v1beta.query.QueryService", "ReadUtxos"),
131                );
132            self.inner.unary(req, path, codec).await
133        }
134        ///
135        pub async fn search_utxos(
136            &mut self,
137            request: impl tonic::IntoRequest<super::SearchUtxosRequest>,
138        ) -> std::result::Result<
139            tonic::Response<super::SearchUtxosResponse>,
140            tonic::Status,
141        > {
142            self.inner
143                .ready()
144                .await
145                .map_err(|e| {
146                    tonic::Status::new(
147                        tonic::Code::Unknown,
148                        format!("Service was not ready: {}", e.into()),
149                    )
150                })?;
151            let codec = tonic::codec::ProstCodec::default();
152            let path = http::uri::PathAndQuery::from_static(
153                "/utxorpc.v1beta.query.QueryService/SearchUtxos",
154            );
155            let mut req = request.into_request();
156            req.extensions_mut()
157                .insert(
158                    GrpcMethod::new("utxorpc.v1beta.query.QueryService", "SearchUtxos"),
159                );
160            self.inner.unary(req, path, codec).await
161        }
162        ///
163        pub async fn read_data(
164            &mut self,
165            request: impl tonic::IntoRequest<super::ReadDataRequest>,
166        ) -> std::result::Result<
167            tonic::Response<super::ReadDataResponse>,
168            tonic::Status,
169        > {
170            self.inner
171                .ready()
172                .await
173                .map_err(|e| {
174                    tonic::Status::new(
175                        tonic::Code::Unknown,
176                        format!("Service was not ready: {}", e.into()),
177                    )
178                })?;
179            let codec = tonic::codec::ProstCodec::default();
180            let path = http::uri::PathAndQuery::from_static(
181                "/utxorpc.v1beta.query.QueryService/ReadData",
182            );
183            let mut req = request.into_request();
184            req.extensions_mut()
185                .insert(
186                    GrpcMethod::new("utxorpc.v1beta.query.QueryService", "ReadData"),
187                );
188            self.inner.unary(req, path, codec).await
189        }
190        ///
191        pub async fn read_tx(
192            &mut self,
193            request: impl tonic::IntoRequest<super::ReadTxRequest>,
194        ) -> std::result::Result<tonic::Response<super::ReadTxResponse>, tonic::Status> {
195            self.inner
196                .ready()
197                .await
198                .map_err(|e| {
199                    tonic::Status::new(
200                        tonic::Code::Unknown,
201                        format!("Service was not ready: {}", e.into()),
202                    )
203                })?;
204            let codec = tonic::codec::ProstCodec::default();
205            let path = http::uri::PathAndQuery::from_static(
206                "/utxorpc.v1beta.query.QueryService/ReadTx",
207            );
208            let mut req = request.into_request();
209            req.extensions_mut()
210                .insert(GrpcMethod::new("utxorpc.v1beta.query.QueryService", "ReadTx"));
211            self.inner.unary(req, path, codec).await
212        }
213        ///
214        pub async fn read_genesis(
215            &mut self,
216            request: impl tonic::IntoRequest<super::ReadGenesisRequest>,
217        ) -> std::result::Result<
218            tonic::Response<super::ReadGenesisResponse>,
219            tonic::Status,
220        > {
221            self.inner
222                .ready()
223                .await
224                .map_err(|e| {
225                    tonic::Status::new(
226                        tonic::Code::Unknown,
227                        format!("Service was not ready: {}", e.into()),
228                    )
229                })?;
230            let codec = tonic::codec::ProstCodec::default();
231            let path = http::uri::PathAndQuery::from_static(
232                "/utxorpc.v1beta.query.QueryService/ReadGenesis",
233            );
234            let mut req = request.into_request();
235            req.extensions_mut()
236                .insert(
237                    GrpcMethod::new("utxorpc.v1beta.query.QueryService", "ReadGenesis"),
238                );
239            self.inner.unary(req, path, codec).await
240        }
241        ///
242        pub async fn read_era_summary(
243            &mut self,
244            request: impl tonic::IntoRequest<super::ReadEraSummaryRequest>,
245        ) -> std::result::Result<
246            tonic::Response<super::ReadEraSummaryResponse>,
247            tonic::Status,
248        > {
249            self.inner
250                .ready()
251                .await
252                .map_err(|e| {
253                    tonic::Status::new(
254                        tonic::Code::Unknown,
255                        format!("Service was not ready: {}", e.into()),
256                    )
257                })?;
258            let codec = tonic::codec::ProstCodec::default();
259            let path = http::uri::PathAndQuery::from_static(
260                "/utxorpc.v1beta.query.QueryService/ReadEraSummary",
261            );
262            let mut req = request.into_request();
263            req.extensions_mut()
264                .insert(
265                    GrpcMethod::new(
266                        "utxorpc.v1beta.query.QueryService",
267                        "ReadEraSummary",
268                    ),
269                );
270            self.inner.unary(req, path, codec).await
271        }
272        ///
273        pub async fn read_state(
274            &mut self,
275            request: impl tonic::IntoRequest<super::ReadStateRequest>,
276        ) -> std::result::Result<
277            tonic::Response<super::ReadStateResponse>,
278            tonic::Status,
279        > {
280            self.inner
281                .ready()
282                .await
283                .map_err(|e| {
284                    tonic::Status::new(
285                        tonic::Code::Unknown,
286                        format!("Service was not ready: {}", e.into()),
287                    )
288                })?;
289            let codec = tonic::codec::ProstCodec::default();
290            let path = http::uri::PathAndQuery::from_static(
291                "/utxorpc.v1beta.query.QueryService/ReadState",
292            );
293            let mut req = request.into_request();
294            req.extensions_mut()
295                .insert(
296                    GrpcMethod::new("utxorpc.v1beta.query.QueryService", "ReadState"),
297                );
298            self.inner.unary(req, path, codec).await
299        }
300    }
301}
302/// Generated server implementations.
303pub mod query_service_server {
304    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
305    use tonic::codegen::*;
306    /// Generated trait containing gRPC methods that should be implemented for use with QueryServiceServer.
307    #[async_trait]
308    pub trait QueryService: Send + Sync + 'static {
309        ///
310        async fn read_params(
311            &self,
312            request: tonic::Request<super::ReadParamsRequest>,
313        ) -> std::result::Result<
314            tonic::Response<super::ReadParamsResponse>,
315            tonic::Status,
316        >;
317        ///
318        async fn read_utxos(
319            &self,
320            request: tonic::Request<super::ReadUtxosRequest>,
321        ) -> std::result::Result<
322            tonic::Response<super::ReadUtxosResponse>,
323            tonic::Status,
324        >;
325        ///
326        async fn search_utxos(
327            &self,
328            request: tonic::Request<super::SearchUtxosRequest>,
329        ) -> std::result::Result<
330            tonic::Response<super::SearchUtxosResponse>,
331            tonic::Status,
332        >;
333        ///
334        async fn read_data(
335            &self,
336            request: tonic::Request<super::ReadDataRequest>,
337        ) -> std::result::Result<
338            tonic::Response<super::ReadDataResponse>,
339            tonic::Status,
340        >;
341        ///
342        async fn read_tx(
343            &self,
344            request: tonic::Request<super::ReadTxRequest>,
345        ) -> std::result::Result<tonic::Response<super::ReadTxResponse>, tonic::Status>;
346        ///
347        async fn read_genesis(
348            &self,
349            request: tonic::Request<super::ReadGenesisRequest>,
350        ) -> std::result::Result<
351            tonic::Response<super::ReadGenesisResponse>,
352            tonic::Status,
353        >;
354        ///
355        async fn read_era_summary(
356            &self,
357            request: tonic::Request<super::ReadEraSummaryRequest>,
358        ) -> std::result::Result<
359            tonic::Response<super::ReadEraSummaryResponse>,
360            tonic::Status,
361        >;
362        ///
363        async fn read_state(
364            &self,
365            request: tonic::Request<super::ReadStateRequest>,
366        ) -> std::result::Result<
367            tonic::Response<super::ReadStateResponse>,
368            tonic::Status,
369        >;
370    }
371    /** Service definition for querying the state of the chain.
372*/
373    #[derive(Debug)]
374    pub struct QueryServiceServer<T: QueryService> {
375        inner: _Inner<T>,
376        accept_compression_encodings: EnabledCompressionEncodings,
377        send_compression_encodings: EnabledCompressionEncodings,
378        max_decoding_message_size: Option<usize>,
379        max_encoding_message_size: Option<usize>,
380    }
381    struct _Inner<T>(Arc<T>);
382    impl<T: QueryService> QueryServiceServer<T> {
383        pub fn new(inner: T) -> Self {
384            Self::from_arc(Arc::new(inner))
385        }
386        pub fn from_arc(inner: Arc<T>) -> Self {
387            let inner = _Inner(inner);
388            Self {
389                inner,
390                accept_compression_encodings: Default::default(),
391                send_compression_encodings: Default::default(),
392                max_decoding_message_size: None,
393                max_encoding_message_size: None,
394            }
395        }
396        pub fn with_interceptor<F>(
397            inner: T,
398            interceptor: F,
399        ) -> InterceptedService<Self, F>
400        where
401            F: tonic::service::Interceptor,
402        {
403            InterceptedService::new(Self::new(inner), interceptor)
404        }
405        /// Enable decompressing requests with the given encoding.
406        #[must_use]
407        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
408            self.accept_compression_encodings.enable(encoding);
409            self
410        }
411        /// Compress responses with the given encoding, if the client supports it.
412        #[must_use]
413        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
414            self.send_compression_encodings.enable(encoding);
415            self
416        }
417        /// Limits the maximum size of a decoded message.
418        ///
419        /// Default: `4MB`
420        #[must_use]
421        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
422            self.max_decoding_message_size = Some(limit);
423            self
424        }
425        /// Limits the maximum size of an encoded message.
426        ///
427        /// Default: `usize::MAX`
428        #[must_use]
429        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
430            self.max_encoding_message_size = Some(limit);
431            self
432        }
433    }
434    impl<T, B> tonic::codegen::Service<http::Request<B>> for QueryServiceServer<T>
435    where
436        T: QueryService,
437        B: Body + Send + 'static,
438        B::Error: Into<StdError> + Send + 'static,
439    {
440        type Response = http::Response<tonic::body::BoxBody>;
441        type Error = std::convert::Infallible;
442        type Future = BoxFuture<Self::Response, Self::Error>;
443        fn poll_ready(
444            &mut self,
445            _cx: &mut Context<'_>,
446        ) -> Poll<std::result::Result<(), Self::Error>> {
447            Poll::Ready(Ok(()))
448        }
449        fn call(&mut self, req: http::Request<B>) -> Self::Future {
450            let inner = self.inner.clone();
451            match req.uri().path() {
452                "/utxorpc.v1beta.query.QueryService/ReadParams" => {
453                    #[allow(non_camel_case_types)]
454                    struct ReadParamsSvc<T: QueryService>(pub Arc<T>);
455                    impl<
456                        T: QueryService,
457                    > tonic::server::UnaryService<super::ReadParamsRequest>
458                    for ReadParamsSvc<T> {
459                        type Response = super::ReadParamsResponse;
460                        type Future = BoxFuture<
461                            tonic::Response<Self::Response>,
462                            tonic::Status,
463                        >;
464                        fn call(
465                            &mut self,
466                            request: tonic::Request<super::ReadParamsRequest>,
467                        ) -> Self::Future {
468                            let inner = Arc::clone(&self.0);
469                            let fut = async move {
470                                <T as QueryService>::read_params(&inner, request).await
471                            };
472                            Box::pin(fut)
473                        }
474                    }
475                    let accept_compression_encodings = self.accept_compression_encodings;
476                    let send_compression_encodings = self.send_compression_encodings;
477                    let max_decoding_message_size = self.max_decoding_message_size;
478                    let max_encoding_message_size = self.max_encoding_message_size;
479                    let inner = self.inner.clone();
480                    let fut = async move {
481                        let inner = inner.0;
482                        let method = ReadParamsSvc(inner);
483                        let codec = tonic::codec::ProstCodec::default();
484                        let mut grpc = tonic::server::Grpc::new(codec)
485                            .apply_compression_config(
486                                accept_compression_encodings,
487                                send_compression_encodings,
488                            )
489                            .apply_max_message_size_config(
490                                max_decoding_message_size,
491                                max_encoding_message_size,
492                            );
493                        let res = grpc.unary(method, req).await;
494                        Ok(res)
495                    };
496                    Box::pin(fut)
497                }
498                "/utxorpc.v1beta.query.QueryService/ReadUtxos" => {
499                    #[allow(non_camel_case_types)]
500                    struct ReadUtxosSvc<T: QueryService>(pub Arc<T>);
501                    impl<
502                        T: QueryService,
503                    > tonic::server::UnaryService<super::ReadUtxosRequest>
504                    for ReadUtxosSvc<T> {
505                        type Response = super::ReadUtxosResponse;
506                        type Future = BoxFuture<
507                            tonic::Response<Self::Response>,
508                            tonic::Status,
509                        >;
510                        fn call(
511                            &mut self,
512                            request: tonic::Request<super::ReadUtxosRequest>,
513                        ) -> Self::Future {
514                            let inner = Arc::clone(&self.0);
515                            let fut = async move {
516                                <T as QueryService>::read_utxos(&inner, request).await
517                            };
518                            Box::pin(fut)
519                        }
520                    }
521                    let accept_compression_encodings = self.accept_compression_encodings;
522                    let send_compression_encodings = self.send_compression_encodings;
523                    let max_decoding_message_size = self.max_decoding_message_size;
524                    let max_encoding_message_size = self.max_encoding_message_size;
525                    let inner = self.inner.clone();
526                    let fut = async move {
527                        let inner = inner.0;
528                        let method = ReadUtxosSvc(inner);
529                        let codec = tonic::codec::ProstCodec::default();
530                        let mut grpc = tonic::server::Grpc::new(codec)
531                            .apply_compression_config(
532                                accept_compression_encodings,
533                                send_compression_encodings,
534                            )
535                            .apply_max_message_size_config(
536                                max_decoding_message_size,
537                                max_encoding_message_size,
538                            );
539                        let res = grpc.unary(method, req).await;
540                        Ok(res)
541                    };
542                    Box::pin(fut)
543                }
544                "/utxorpc.v1beta.query.QueryService/SearchUtxos" => {
545                    #[allow(non_camel_case_types)]
546                    struct SearchUtxosSvc<T: QueryService>(pub Arc<T>);
547                    impl<
548                        T: QueryService,
549                    > tonic::server::UnaryService<super::SearchUtxosRequest>
550                    for SearchUtxosSvc<T> {
551                        type Response = super::SearchUtxosResponse;
552                        type Future = BoxFuture<
553                            tonic::Response<Self::Response>,
554                            tonic::Status,
555                        >;
556                        fn call(
557                            &mut self,
558                            request: tonic::Request<super::SearchUtxosRequest>,
559                        ) -> Self::Future {
560                            let inner = Arc::clone(&self.0);
561                            let fut = async move {
562                                <T as QueryService>::search_utxos(&inner, request).await
563                            };
564                            Box::pin(fut)
565                        }
566                    }
567                    let accept_compression_encodings = self.accept_compression_encodings;
568                    let send_compression_encodings = self.send_compression_encodings;
569                    let max_decoding_message_size = self.max_decoding_message_size;
570                    let max_encoding_message_size = self.max_encoding_message_size;
571                    let inner = self.inner.clone();
572                    let fut = async move {
573                        let inner = inner.0;
574                        let method = SearchUtxosSvc(inner);
575                        let codec = tonic::codec::ProstCodec::default();
576                        let mut grpc = tonic::server::Grpc::new(codec)
577                            .apply_compression_config(
578                                accept_compression_encodings,
579                                send_compression_encodings,
580                            )
581                            .apply_max_message_size_config(
582                                max_decoding_message_size,
583                                max_encoding_message_size,
584                            );
585                        let res = grpc.unary(method, req).await;
586                        Ok(res)
587                    };
588                    Box::pin(fut)
589                }
590                "/utxorpc.v1beta.query.QueryService/ReadData" => {
591                    #[allow(non_camel_case_types)]
592                    struct ReadDataSvc<T: QueryService>(pub Arc<T>);
593                    impl<
594                        T: QueryService,
595                    > tonic::server::UnaryService<super::ReadDataRequest>
596                    for ReadDataSvc<T> {
597                        type Response = super::ReadDataResponse;
598                        type Future = BoxFuture<
599                            tonic::Response<Self::Response>,
600                            tonic::Status,
601                        >;
602                        fn call(
603                            &mut self,
604                            request: tonic::Request<super::ReadDataRequest>,
605                        ) -> Self::Future {
606                            let inner = Arc::clone(&self.0);
607                            let fut = async move {
608                                <T as QueryService>::read_data(&inner, request).await
609                            };
610                            Box::pin(fut)
611                        }
612                    }
613                    let accept_compression_encodings = self.accept_compression_encodings;
614                    let send_compression_encodings = self.send_compression_encodings;
615                    let max_decoding_message_size = self.max_decoding_message_size;
616                    let max_encoding_message_size = self.max_encoding_message_size;
617                    let inner = self.inner.clone();
618                    let fut = async move {
619                        let inner = inner.0;
620                        let method = ReadDataSvc(inner);
621                        let codec = tonic::codec::ProstCodec::default();
622                        let mut grpc = tonic::server::Grpc::new(codec)
623                            .apply_compression_config(
624                                accept_compression_encodings,
625                                send_compression_encodings,
626                            )
627                            .apply_max_message_size_config(
628                                max_decoding_message_size,
629                                max_encoding_message_size,
630                            );
631                        let res = grpc.unary(method, req).await;
632                        Ok(res)
633                    };
634                    Box::pin(fut)
635                }
636                "/utxorpc.v1beta.query.QueryService/ReadTx" => {
637                    #[allow(non_camel_case_types)]
638                    struct ReadTxSvc<T: QueryService>(pub Arc<T>);
639                    impl<
640                        T: QueryService,
641                    > tonic::server::UnaryService<super::ReadTxRequest>
642                    for ReadTxSvc<T> {
643                        type Response = super::ReadTxResponse;
644                        type Future = BoxFuture<
645                            tonic::Response<Self::Response>,
646                            tonic::Status,
647                        >;
648                        fn call(
649                            &mut self,
650                            request: tonic::Request<super::ReadTxRequest>,
651                        ) -> Self::Future {
652                            let inner = Arc::clone(&self.0);
653                            let fut = async move {
654                                <T as QueryService>::read_tx(&inner, request).await
655                            };
656                            Box::pin(fut)
657                        }
658                    }
659                    let accept_compression_encodings = self.accept_compression_encodings;
660                    let send_compression_encodings = self.send_compression_encodings;
661                    let max_decoding_message_size = self.max_decoding_message_size;
662                    let max_encoding_message_size = self.max_encoding_message_size;
663                    let inner = self.inner.clone();
664                    let fut = async move {
665                        let inner = inner.0;
666                        let method = ReadTxSvc(inner);
667                        let codec = tonic::codec::ProstCodec::default();
668                        let mut grpc = tonic::server::Grpc::new(codec)
669                            .apply_compression_config(
670                                accept_compression_encodings,
671                                send_compression_encodings,
672                            )
673                            .apply_max_message_size_config(
674                                max_decoding_message_size,
675                                max_encoding_message_size,
676                            );
677                        let res = grpc.unary(method, req).await;
678                        Ok(res)
679                    };
680                    Box::pin(fut)
681                }
682                "/utxorpc.v1beta.query.QueryService/ReadGenesis" => {
683                    #[allow(non_camel_case_types)]
684                    struct ReadGenesisSvc<T: QueryService>(pub Arc<T>);
685                    impl<
686                        T: QueryService,
687                    > tonic::server::UnaryService<super::ReadGenesisRequest>
688                    for ReadGenesisSvc<T> {
689                        type Response = super::ReadGenesisResponse;
690                        type Future = BoxFuture<
691                            tonic::Response<Self::Response>,
692                            tonic::Status,
693                        >;
694                        fn call(
695                            &mut self,
696                            request: tonic::Request<super::ReadGenesisRequest>,
697                        ) -> Self::Future {
698                            let inner = Arc::clone(&self.0);
699                            let fut = async move {
700                                <T as QueryService>::read_genesis(&inner, request).await
701                            };
702                            Box::pin(fut)
703                        }
704                    }
705                    let accept_compression_encodings = self.accept_compression_encodings;
706                    let send_compression_encodings = self.send_compression_encodings;
707                    let max_decoding_message_size = self.max_decoding_message_size;
708                    let max_encoding_message_size = self.max_encoding_message_size;
709                    let inner = self.inner.clone();
710                    let fut = async move {
711                        let inner = inner.0;
712                        let method = ReadGenesisSvc(inner);
713                        let codec = tonic::codec::ProstCodec::default();
714                        let mut grpc = tonic::server::Grpc::new(codec)
715                            .apply_compression_config(
716                                accept_compression_encodings,
717                                send_compression_encodings,
718                            )
719                            .apply_max_message_size_config(
720                                max_decoding_message_size,
721                                max_encoding_message_size,
722                            );
723                        let res = grpc.unary(method, req).await;
724                        Ok(res)
725                    };
726                    Box::pin(fut)
727                }
728                "/utxorpc.v1beta.query.QueryService/ReadEraSummary" => {
729                    #[allow(non_camel_case_types)]
730                    struct ReadEraSummarySvc<T: QueryService>(pub Arc<T>);
731                    impl<
732                        T: QueryService,
733                    > tonic::server::UnaryService<super::ReadEraSummaryRequest>
734                    for ReadEraSummarySvc<T> {
735                        type Response = super::ReadEraSummaryResponse;
736                        type Future = BoxFuture<
737                            tonic::Response<Self::Response>,
738                            tonic::Status,
739                        >;
740                        fn call(
741                            &mut self,
742                            request: tonic::Request<super::ReadEraSummaryRequest>,
743                        ) -> Self::Future {
744                            let inner = Arc::clone(&self.0);
745                            let fut = async move {
746                                <T as QueryService>::read_era_summary(&inner, request).await
747                            };
748                            Box::pin(fut)
749                        }
750                    }
751                    let accept_compression_encodings = self.accept_compression_encodings;
752                    let send_compression_encodings = self.send_compression_encodings;
753                    let max_decoding_message_size = self.max_decoding_message_size;
754                    let max_encoding_message_size = self.max_encoding_message_size;
755                    let inner = self.inner.clone();
756                    let fut = async move {
757                        let inner = inner.0;
758                        let method = ReadEraSummarySvc(inner);
759                        let codec = tonic::codec::ProstCodec::default();
760                        let mut grpc = tonic::server::Grpc::new(codec)
761                            .apply_compression_config(
762                                accept_compression_encodings,
763                                send_compression_encodings,
764                            )
765                            .apply_max_message_size_config(
766                                max_decoding_message_size,
767                                max_encoding_message_size,
768                            );
769                        let res = grpc.unary(method, req).await;
770                        Ok(res)
771                    };
772                    Box::pin(fut)
773                }
774                "/utxorpc.v1beta.query.QueryService/ReadState" => {
775                    #[allow(non_camel_case_types)]
776                    struct ReadStateSvc<T: QueryService>(pub Arc<T>);
777                    impl<
778                        T: QueryService,
779                    > tonic::server::UnaryService<super::ReadStateRequest>
780                    for ReadStateSvc<T> {
781                        type Response = super::ReadStateResponse;
782                        type Future = BoxFuture<
783                            tonic::Response<Self::Response>,
784                            tonic::Status,
785                        >;
786                        fn call(
787                            &mut self,
788                            request: tonic::Request<super::ReadStateRequest>,
789                        ) -> Self::Future {
790                            let inner = Arc::clone(&self.0);
791                            let fut = async move {
792                                <T as QueryService>::read_state(&inner, request).await
793                            };
794                            Box::pin(fut)
795                        }
796                    }
797                    let accept_compression_encodings = self.accept_compression_encodings;
798                    let send_compression_encodings = self.send_compression_encodings;
799                    let max_decoding_message_size = self.max_decoding_message_size;
800                    let max_encoding_message_size = self.max_encoding_message_size;
801                    let inner = self.inner.clone();
802                    let fut = async move {
803                        let inner = inner.0;
804                        let method = ReadStateSvc(inner);
805                        let codec = tonic::codec::ProstCodec::default();
806                        let mut grpc = tonic::server::Grpc::new(codec)
807                            .apply_compression_config(
808                                accept_compression_encodings,
809                                send_compression_encodings,
810                            )
811                            .apply_max_message_size_config(
812                                max_decoding_message_size,
813                                max_encoding_message_size,
814                            );
815                        let res = grpc.unary(method, req).await;
816                        Ok(res)
817                    };
818                    Box::pin(fut)
819                }
820                _ => {
821                    Box::pin(async move {
822                        Ok(
823                            http::Response::builder()
824                                .status(200)
825                                .header("grpc-status", "12")
826                                .header("content-type", "application/grpc")
827                                .body(empty_body())
828                                .unwrap(),
829                        )
830                    })
831                }
832            }
833        }
834    }
835    impl<T: QueryService> Clone for QueryServiceServer<T> {
836        fn clone(&self) -> Self {
837            let inner = self.inner.clone();
838            Self {
839                inner,
840                accept_compression_encodings: self.accept_compression_encodings,
841                send_compression_encodings: self.send_compression_encodings,
842                max_decoding_message_size: self.max_decoding_message_size,
843                max_encoding_message_size: self.max_encoding_message_size,
844            }
845        }
846    }
847    impl<T: QueryService> Clone for _Inner<T> {
848        fn clone(&self) -> Self {
849            Self(Arc::clone(&self.0))
850        }
851    }
852    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
853        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
854            write!(f, "{:?}", self.0)
855        }
856    }
857    impl<T: QueryService> tonic::server::NamedService for QueryServiceServer<T> {
858        const NAME: &'static str = "utxorpc.v1beta.query.QueryService";
859    }
860}
utxorpc_spec/utxorpc.v1beta.query.tonic.rs

utxorpc_spec/
utxorpc.v1beta.query.tonic.rs
