ledger_models/
fintekkers.services.security_service.rs

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

ledger_models/
fintekkers.services.security_service.rs
