utxorpc_spec/
utxorpc.v1alpha.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.v1alpha.query.QueryService/ReadParams",
98            );
99            let mut req = request.into_request();
100            req.extensions_mut()
101                .insert(
102                    GrpcMethod::new("utxorpc.v1alpha.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.v1alpha.query.QueryService/ReadUtxos",
126            );
127            let mut req = request.into_request();
128            req.extensions_mut()
129                .insert(
130                    GrpcMethod::new("utxorpc.v1alpha.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.v1alpha.query.QueryService/SearchUtxos",
154            );
155            let mut req = request.into_request();
156            req.extensions_mut()
157                .insert(
158                    GrpcMethod::new("utxorpc.v1alpha.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.v1alpha.query.QueryService/ReadData",
182            );
183            let mut req = request.into_request();
184            req.extensions_mut()
185                .insert(
186                    GrpcMethod::new("utxorpc.v1alpha.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.v1alpha.query.QueryService/ReadTx",
207            );
208            let mut req = request.into_request();
209            req.extensions_mut()
210                .insert(GrpcMethod::new("utxorpc.v1alpha.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.v1alpha.query.QueryService/ReadGenesis",
233            );
234            let mut req = request.into_request();
235            req.extensions_mut()
236                .insert(
237                    GrpcMethod::new("utxorpc.v1alpha.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.v1alpha.query.QueryService/ReadEraSummary",
261            );
262            let mut req = request.into_request();
263            req.extensions_mut()
264                .insert(
265                    GrpcMethod::new(
266                        "utxorpc.v1alpha.query.QueryService",
267                        "ReadEraSummary",
268                    ),
269                );
270            self.inner.unary(req, path, codec).await
271        }
272    }
273}
274/// Generated server implementations.
275pub mod query_service_server {
276    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
277    use tonic::codegen::*;
278    /// Generated trait containing gRPC methods that should be implemented for use with QueryServiceServer.
279    #[async_trait]
280    pub trait QueryService: Send + Sync + 'static {
281        ///
282        async fn read_params(
283            &self,
284            request: tonic::Request<super::ReadParamsRequest>,
285        ) -> std::result::Result<
286            tonic::Response<super::ReadParamsResponse>,
287            tonic::Status,
288        >;
289        ///
290        async fn read_utxos(
291            &self,
292            request: tonic::Request<super::ReadUtxosRequest>,
293        ) -> std::result::Result<
294            tonic::Response<super::ReadUtxosResponse>,
295            tonic::Status,
296        >;
297        ///
298        async fn search_utxos(
299            &self,
300            request: tonic::Request<super::SearchUtxosRequest>,
301        ) -> std::result::Result<
302            tonic::Response<super::SearchUtxosResponse>,
303            tonic::Status,
304        >;
305        ///
306        async fn read_data(
307            &self,
308            request: tonic::Request<super::ReadDataRequest>,
309        ) -> std::result::Result<
310            tonic::Response<super::ReadDataResponse>,
311            tonic::Status,
312        >;
313        ///
314        async fn read_tx(
315            &self,
316            request: tonic::Request<super::ReadTxRequest>,
317        ) -> std::result::Result<tonic::Response<super::ReadTxResponse>, tonic::Status>;
318        ///
319        async fn read_genesis(
320            &self,
321            request: tonic::Request<super::ReadGenesisRequest>,
322        ) -> std::result::Result<
323            tonic::Response<super::ReadGenesisResponse>,
324            tonic::Status,
325        >;
326        ///
327        async fn read_era_summary(
328            &self,
329            request: tonic::Request<super::ReadEraSummaryRequest>,
330        ) -> std::result::Result<
331            tonic::Response<super::ReadEraSummaryResponse>,
332            tonic::Status,
333        >;
334    }
335    /** Service definition for querying the state of the chain.
336*/
337    #[derive(Debug)]
338    pub struct QueryServiceServer<T: QueryService> {
339        inner: _Inner<T>,
340        accept_compression_encodings: EnabledCompressionEncodings,
341        send_compression_encodings: EnabledCompressionEncodings,
342        max_decoding_message_size: Option<usize>,
343        max_encoding_message_size: Option<usize>,
344    }
345    struct _Inner<T>(Arc<T>);
346    impl<T: QueryService> QueryServiceServer<T> {
347        pub fn new(inner: T) -> Self {
348            Self::from_arc(Arc::new(inner))
349        }
350        pub fn from_arc(inner: Arc<T>) -> Self {
351            let inner = _Inner(inner);
352            Self {
353                inner,
354                accept_compression_encodings: Default::default(),
355                send_compression_encodings: Default::default(),
356                max_decoding_message_size: None,
357                max_encoding_message_size: None,
358            }
359        }
360        pub fn with_interceptor<F>(
361            inner: T,
362            interceptor: F,
363        ) -> InterceptedService<Self, F>
364        where
365            F: tonic::service::Interceptor,
366        {
367            InterceptedService::new(Self::new(inner), interceptor)
368        }
369        /// Enable decompressing requests with the given encoding.
370        #[must_use]
371        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
372            self.accept_compression_encodings.enable(encoding);
373            self
374        }
375        /// Compress responses with the given encoding, if the client supports it.
376        #[must_use]
377        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
378            self.send_compression_encodings.enable(encoding);
379            self
380        }
381        /// Limits the maximum size of a decoded message.
382        ///
383        /// Default: `4MB`
384        #[must_use]
385        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
386            self.max_decoding_message_size = Some(limit);
387            self
388        }
389        /// Limits the maximum size of an encoded message.
390        ///
391        /// Default: `usize::MAX`
392        #[must_use]
393        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
394            self.max_encoding_message_size = Some(limit);
395            self
396        }
397    }
398    impl<T, B> tonic::codegen::Service<http::Request<B>> for QueryServiceServer<T>
399    where
400        T: QueryService,
401        B: Body + Send + 'static,
402        B::Error: Into<StdError> + Send + 'static,
403    {
404        type Response = http::Response<tonic::body::BoxBody>;
405        type Error = std::convert::Infallible;
406        type Future = BoxFuture<Self::Response, Self::Error>;
407        fn poll_ready(
408            &mut self,
409            _cx: &mut Context<'_>,
410        ) -> Poll<std::result::Result<(), Self::Error>> {
411            Poll::Ready(Ok(()))
412        }
413        fn call(&mut self, req: http::Request<B>) -> Self::Future {
414            let inner = self.inner.clone();
415            match req.uri().path() {
416                "/utxorpc.v1alpha.query.QueryService/ReadParams" => {
417                    #[allow(non_camel_case_types)]
418                    struct ReadParamsSvc<T: QueryService>(pub Arc<T>);
419                    impl<
420                        T: QueryService,
421                    > tonic::server::UnaryService<super::ReadParamsRequest>
422                    for ReadParamsSvc<T> {
423                        type Response = super::ReadParamsResponse;
424                        type Future = BoxFuture<
425                            tonic::Response<Self::Response>,
426                            tonic::Status,
427                        >;
428                        fn call(
429                            &mut self,
430                            request: tonic::Request<super::ReadParamsRequest>,
431                        ) -> Self::Future {
432                            let inner = Arc::clone(&self.0);
433                            let fut = async move {
434                                <T as QueryService>::read_params(&inner, request).await
435                            };
436                            Box::pin(fut)
437                        }
438                    }
439                    let accept_compression_encodings = self.accept_compression_encodings;
440                    let send_compression_encodings = self.send_compression_encodings;
441                    let max_decoding_message_size = self.max_decoding_message_size;
442                    let max_encoding_message_size = self.max_encoding_message_size;
443                    let inner = self.inner.clone();
444                    let fut = async move {
445                        let inner = inner.0;
446                        let method = ReadParamsSvc(inner);
447                        let codec = tonic::codec::ProstCodec::default();
448                        let mut grpc = tonic::server::Grpc::new(codec)
449                            .apply_compression_config(
450                                accept_compression_encodings,
451                                send_compression_encodings,
452                            )
453                            .apply_max_message_size_config(
454                                max_decoding_message_size,
455                                max_encoding_message_size,
456                            );
457                        let res = grpc.unary(method, req).await;
458                        Ok(res)
459                    };
460                    Box::pin(fut)
461                }
462                "/utxorpc.v1alpha.query.QueryService/ReadUtxos" => {
463                    #[allow(non_camel_case_types)]
464                    struct ReadUtxosSvc<T: QueryService>(pub Arc<T>);
465                    impl<
466                        T: QueryService,
467                    > tonic::server::UnaryService<super::ReadUtxosRequest>
468                    for ReadUtxosSvc<T> {
469                        type Response = super::ReadUtxosResponse;
470                        type Future = BoxFuture<
471                            tonic::Response<Self::Response>,
472                            tonic::Status,
473                        >;
474                        fn call(
475                            &mut self,
476                            request: tonic::Request<super::ReadUtxosRequest>,
477                        ) -> Self::Future {
478                            let inner = Arc::clone(&self.0);
479                            let fut = async move {
480                                <T as QueryService>::read_utxos(&inner, request).await
481                            };
482                            Box::pin(fut)
483                        }
484                    }
485                    let accept_compression_encodings = self.accept_compression_encodings;
486                    let send_compression_encodings = self.send_compression_encodings;
487                    let max_decoding_message_size = self.max_decoding_message_size;
488                    let max_encoding_message_size = self.max_encoding_message_size;
489                    let inner = self.inner.clone();
490                    let fut = async move {
491                        let inner = inner.0;
492                        let method = ReadUtxosSvc(inner);
493                        let codec = tonic::codec::ProstCodec::default();
494                        let mut grpc = tonic::server::Grpc::new(codec)
495                            .apply_compression_config(
496                                accept_compression_encodings,
497                                send_compression_encodings,
498                            )
499                            .apply_max_message_size_config(
500                                max_decoding_message_size,
501                                max_encoding_message_size,
502                            );
503                        let res = grpc.unary(method, req).await;
504                        Ok(res)
505                    };
506                    Box::pin(fut)
507                }
508                "/utxorpc.v1alpha.query.QueryService/SearchUtxos" => {
509                    #[allow(non_camel_case_types)]
510                    struct SearchUtxosSvc<T: QueryService>(pub Arc<T>);
511                    impl<
512                        T: QueryService,
513                    > tonic::server::UnaryService<super::SearchUtxosRequest>
514                    for SearchUtxosSvc<T> {
515                        type Response = super::SearchUtxosResponse;
516                        type Future = BoxFuture<
517                            tonic::Response<Self::Response>,
518                            tonic::Status,
519                        >;
520                        fn call(
521                            &mut self,
522                            request: tonic::Request<super::SearchUtxosRequest>,
523                        ) -> Self::Future {
524                            let inner = Arc::clone(&self.0);
525                            let fut = async move {
526                                <T as QueryService>::search_utxos(&inner, request).await
527                            };
528                            Box::pin(fut)
529                        }
530                    }
531                    let accept_compression_encodings = self.accept_compression_encodings;
532                    let send_compression_encodings = self.send_compression_encodings;
533                    let max_decoding_message_size = self.max_decoding_message_size;
534                    let max_encoding_message_size = self.max_encoding_message_size;
535                    let inner = self.inner.clone();
536                    let fut = async move {
537                        let inner = inner.0;
538                        let method = SearchUtxosSvc(inner);
539                        let codec = tonic::codec::ProstCodec::default();
540                        let mut grpc = tonic::server::Grpc::new(codec)
541                            .apply_compression_config(
542                                accept_compression_encodings,
543                                send_compression_encodings,
544                            )
545                            .apply_max_message_size_config(
546                                max_decoding_message_size,
547                                max_encoding_message_size,
548                            );
549                        let res = grpc.unary(method, req).await;
550                        Ok(res)
551                    };
552                    Box::pin(fut)
553                }
554                "/utxorpc.v1alpha.query.QueryService/ReadData" => {
555                    #[allow(non_camel_case_types)]
556                    struct ReadDataSvc<T: QueryService>(pub Arc<T>);
557                    impl<
558                        T: QueryService,
559                    > tonic::server::UnaryService<super::ReadDataRequest>
560                    for ReadDataSvc<T> {
561                        type Response = super::ReadDataResponse;
562                        type Future = BoxFuture<
563                            tonic::Response<Self::Response>,
564                            tonic::Status,
565                        >;
566                        fn call(
567                            &mut self,
568                            request: tonic::Request<super::ReadDataRequest>,
569                        ) -> Self::Future {
570                            let inner = Arc::clone(&self.0);
571                            let fut = async move {
572                                <T as QueryService>::read_data(&inner, request).await
573                            };
574                            Box::pin(fut)
575                        }
576                    }
577                    let accept_compression_encodings = self.accept_compression_encodings;
578                    let send_compression_encodings = self.send_compression_encodings;
579                    let max_decoding_message_size = self.max_decoding_message_size;
580                    let max_encoding_message_size = self.max_encoding_message_size;
581                    let inner = self.inner.clone();
582                    let fut = async move {
583                        let inner = inner.0;
584                        let method = ReadDataSvc(inner);
585                        let codec = tonic::codec::ProstCodec::default();
586                        let mut grpc = tonic::server::Grpc::new(codec)
587                            .apply_compression_config(
588                                accept_compression_encodings,
589                                send_compression_encodings,
590                            )
591                            .apply_max_message_size_config(
592                                max_decoding_message_size,
593                                max_encoding_message_size,
594                            );
595                        let res = grpc.unary(method, req).await;
596                        Ok(res)
597                    };
598                    Box::pin(fut)
599                }
600                "/utxorpc.v1alpha.query.QueryService/ReadTx" => {
601                    #[allow(non_camel_case_types)]
602                    struct ReadTxSvc<T: QueryService>(pub Arc<T>);
603                    impl<
604                        T: QueryService,
605                    > tonic::server::UnaryService<super::ReadTxRequest>
606                    for ReadTxSvc<T> {
607                        type Response = super::ReadTxResponse;
608                        type Future = BoxFuture<
609                            tonic::Response<Self::Response>,
610                            tonic::Status,
611                        >;
612                        fn call(
613                            &mut self,
614                            request: tonic::Request<super::ReadTxRequest>,
615                        ) -> Self::Future {
616                            let inner = Arc::clone(&self.0);
617                            let fut = async move {
618                                <T as QueryService>::read_tx(&inner, request).await
619                            };
620                            Box::pin(fut)
621                        }
622                    }
623                    let accept_compression_encodings = self.accept_compression_encodings;
624                    let send_compression_encodings = self.send_compression_encodings;
625                    let max_decoding_message_size = self.max_decoding_message_size;
626                    let max_encoding_message_size = self.max_encoding_message_size;
627                    let inner = self.inner.clone();
628                    let fut = async move {
629                        let inner = inner.0;
630                        let method = ReadTxSvc(inner);
631                        let codec = tonic::codec::ProstCodec::default();
632                        let mut grpc = tonic::server::Grpc::new(codec)
633                            .apply_compression_config(
634                                accept_compression_encodings,
635                                send_compression_encodings,
636                            )
637                            .apply_max_message_size_config(
638                                max_decoding_message_size,
639                                max_encoding_message_size,
640                            );
641                        let res = grpc.unary(method, req).await;
642                        Ok(res)
643                    };
644                    Box::pin(fut)
645                }
646                "/utxorpc.v1alpha.query.QueryService/ReadGenesis" => {
647                    #[allow(non_camel_case_types)]
648                    struct ReadGenesisSvc<T: QueryService>(pub Arc<T>);
649                    impl<
650                        T: QueryService,
651                    > tonic::server::UnaryService<super::ReadGenesisRequest>
652                    for ReadGenesisSvc<T> {
653                        type Response = super::ReadGenesisResponse;
654                        type Future = BoxFuture<
655                            tonic::Response<Self::Response>,
656                            tonic::Status,
657                        >;
658                        fn call(
659                            &mut self,
660                            request: tonic::Request<super::ReadGenesisRequest>,
661                        ) -> Self::Future {
662                            let inner = Arc::clone(&self.0);
663                            let fut = async move {
664                                <T as QueryService>::read_genesis(&inner, request).await
665                            };
666                            Box::pin(fut)
667                        }
668                    }
669                    let accept_compression_encodings = self.accept_compression_encodings;
670                    let send_compression_encodings = self.send_compression_encodings;
671                    let max_decoding_message_size = self.max_decoding_message_size;
672                    let max_encoding_message_size = self.max_encoding_message_size;
673                    let inner = self.inner.clone();
674                    let fut = async move {
675                        let inner = inner.0;
676                        let method = ReadGenesisSvc(inner);
677                        let codec = tonic::codec::ProstCodec::default();
678                        let mut grpc = tonic::server::Grpc::new(codec)
679                            .apply_compression_config(
680                                accept_compression_encodings,
681                                send_compression_encodings,
682                            )
683                            .apply_max_message_size_config(
684                                max_decoding_message_size,
685                                max_encoding_message_size,
686                            );
687                        let res = grpc.unary(method, req).await;
688                        Ok(res)
689                    };
690                    Box::pin(fut)
691                }
692                "/utxorpc.v1alpha.query.QueryService/ReadEraSummary" => {
693                    #[allow(non_camel_case_types)]
694                    struct ReadEraSummarySvc<T: QueryService>(pub Arc<T>);
695                    impl<
696                        T: QueryService,
697                    > tonic::server::UnaryService<super::ReadEraSummaryRequest>
698                    for ReadEraSummarySvc<T> {
699                        type Response = super::ReadEraSummaryResponse;
700                        type Future = BoxFuture<
701                            tonic::Response<Self::Response>,
702                            tonic::Status,
703                        >;
704                        fn call(
705                            &mut self,
706                            request: tonic::Request<super::ReadEraSummaryRequest>,
707                        ) -> Self::Future {
708                            let inner = Arc::clone(&self.0);
709                            let fut = async move {
710                                <T as QueryService>::read_era_summary(&inner, request).await
711                            };
712                            Box::pin(fut)
713                        }
714                    }
715                    let accept_compression_encodings = self.accept_compression_encodings;
716                    let send_compression_encodings = self.send_compression_encodings;
717                    let max_decoding_message_size = self.max_decoding_message_size;
718                    let max_encoding_message_size = self.max_encoding_message_size;
719                    let inner = self.inner.clone();
720                    let fut = async move {
721                        let inner = inner.0;
722                        let method = ReadEraSummarySvc(inner);
723                        let codec = tonic::codec::ProstCodec::default();
724                        let mut grpc = tonic::server::Grpc::new(codec)
725                            .apply_compression_config(
726                                accept_compression_encodings,
727                                send_compression_encodings,
728                            )
729                            .apply_max_message_size_config(
730                                max_decoding_message_size,
731                                max_encoding_message_size,
732                            );
733                        let res = grpc.unary(method, req).await;
734                        Ok(res)
735                    };
736                    Box::pin(fut)
737                }
738                _ => {
739                    Box::pin(async move {
740                        Ok(
741                            http::Response::builder()
742                                .status(200)
743                                .header("grpc-status", "12")
744                                .header("content-type", "application/grpc")
745                                .body(empty_body())
746                                .unwrap(),
747                        )
748                    })
749                }
750            }
751        }
752    }
753    impl<T: QueryService> Clone for QueryServiceServer<T> {
754        fn clone(&self) -> Self {
755            let inner = self.inner.clone();
756            Self {
757                inner,
758                accept_compression_encodings: self.accept_compression_encodings,
759                send_compression_encodings: self.send_compression_encodings,
760                max_decoding_message_size: self.max_decoding_message_size,
761                max_encoding_message_size: self.max_encoding_message_size,
762            }
763        }
764    }
765    impl<T: QueryService> Clone for _Inner<T> {
766        fn clone(&self) -> Self {
767            Self(Arc::clone(&self.0))
768        }
769    }
770    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
771        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
772            write!(f, "{:?}", self.0)
773        }
774    }
775    impl<T: QueryService> tonic::server::NamedService for QueryServiceServer<T> {
776        const NAME: &'static str = "utxorpc.v1alpha.query.QueryService";
777    }
778}
utxorpc_spec/utxorpc.v1alpha.query.tonic.rs

utxorpc_spec/
utxorpc.v1alpha.query.tonic.rs
