Struct hvcg_governance_openapi_catholic_polity::client::Client[−][src]

pub struct Client<S, C> where
    S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static,
    S::Future: Send + 'static,
    S::Error: Into<Box<dyn Error + Send + Sync + 'static>> + Display,
    C: Clone + Send + Sync + 'static,  { /* fields omitted */ }

Expand description

A client that implements the API by making HTTP calls out to a server.

Implementations

[src]

impl<Connector, C> Client<DropContextService<Client<Connector, Body>, C>, C> where
Connector: Connect + Clone + Send + Sync + 'static,
C: Clone + Send + Sync + 'static,

[src]

pub fn try_new_with_connector(
 base_path: &str,
 protocol: Option<&'static str>,
 connector: Connector
) -> Result<Self, ClientInitError>

Create a client with a custom implementation of hyper::client::Connect.

Intended for use with custom implementations of connect for e.g. protocol logging or similar functionality which requires wrapping the transport layer. When wrapping a TCP connection, this function should be used in conjunction with swagger::Connector::builder().

For ordinary tcp connections, prefer the use of try_new_http, try_new_https and try_new_https_mutual, to avoid introducing a dependency on the underlying transport layer.

Arguments

base_path - base path of the client API, i.e. “http://www.my-api-implementation.com”
protocol - Which protocol to use when constructing the request url, e.g. Some("http")
connector - Implementation of hyper::client::Connect to use for the client

[src]

impl<C> Client<DropContextService<HyperClient, C>, C> where
C: Clone + Send + Sync + 'static,

[src]

pub fn try_new(base_path: &str) -> Result<Self, ClientInitError>

Create an HTTP client.

Arguments

base_path - base path of the client API, i.e. “http://www.my-api-implementation.com”

[src]

impl<C> Client<DropContextService<Client<HttpConnector, Body>, C>, C> where
C: Clone + Send + Sync + 'static,

[src]

pub fn try_new_http(base_path: &str) -> Result<Self, ClientInitError>

Create an HTTP client.

Arguments

base_path - base path of the client API, i.e. “http://www.my-api-implementation.com”

[src]

impl<C> Client<DropContextService<Client<HttpsConnector<HttpConnector>, Body>, C>, C> where
C: Clone + Send + Sync + 'static,

[src]

pub fn try_new_https(base_path: &str) -> Result<Self, ClientInitError>

Create a client with a TLS connection to the server

Arguments

base_path - base path of the client API, i.e. “https://www.my-api-implementation.com”

[src]

impl<S, C> Client<S, C> where
 S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static,
 S::Future: Send + 'static,
 S::Error: Into<Box<dyn Error + Send + Sync + 'static>> + Display,
 C: Clone + Send + Sync + 'static,

[src]

pub fn try_new_with_client_service(
client_service: S,
base_path: &str
) -> Result<Self, ClientInitError>

Constructor for creating a Client by passing in a pre-made hyper::service::Service / tower::Service

This allows adding custom wrappers around the underlying transport, for example for logging.

Trait Implementations

[src]

impl<S, C> Api<C> for Client<S, C> where
 S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static,
 S::Future: Send + 'static,
 S::Error: Into<Box<dyn Error + Send + Sync + 'static>> + Display,
 C: Has<XSpanIdString> + Has<Option<AuthData>> + Clone + Send + Sync + 'static,

[src]

fn poll_ready(
&self,
cx: &mut Context<'_>
) -> Poll<Result<(), Box<dyn Error + Send + Sync + 'static>>>

[src]

fn add_deanery<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_deanery_mutation: DeaneryMutation,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<AddDeaneryResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Add new deanery

[src]

fn delete_deanery<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_id: Uuid,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<DeleteDeaneryResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Delete deanery by ID

[src]

fn get_deaneries<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_diocese_id: Option<Uuid>,
 param_name: Option<String>,
 param_offset: Option<i32>,
 param_count: Option<i32>,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<GetDeaneriesResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Get deaneries

[src]

fn get_deanery_by_id<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_id: Uuid,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<GetDeaneryByIdResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Find deanery by ID

[src]

fn update_deanery<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_id: Uuid,
 param_deanery_mutation: DeaneryMutation,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<UpdateDeaneryResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Update an existing deanery

[src]

fn add_diocese<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_diocese_mutation: DioceseMutation,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<AddDioceseResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Add new diocese

[src]

fn delete_diocese<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_id: Uuid,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<DeleteDioceseResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Delete diocese by ID

[src]

fn get_diocese_by_id<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_id: Uuid,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<GetDioceseByIdResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Find diocese by ID

[src]

fn get_dioceses<'life0, 'life1, 'life2, 'async_trait>(
 &'life0 self,
 param_province_id: Option<Uuid>,
 param_province_code: Option<Code>,
 param_province_name: Option<String>,
 param_name: Option<String>,
 param_location_name: Option<String>,
 param_location_address: Option<String>,
 param_location_email: Option<String>,
 param_person_in_charge: Option<String>,
 param_sorts: Option<&'life1 Vec<DioceseSortCriteria>>,
 param_offset: Option<i32>,
 param_count: Option<i32>,
 context: &'life2 C
) -> Pin<Box<dyn Future<Output = Result<GetDiocesesResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 'life2: 'async_trait,
 Self: 'async_trait,

Get all dioceses

[src]

fn update_diocese<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_id: Uuid,
 param_diocese_mutation: DioceseMutation,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<UpdateDioceseResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Update an existing diocese

[src]

fn add_institute<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_institute_mutation: InstituteMutation,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<AddInstituteResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Add new institute

[src]

fn delete_institute<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_id: Uuid,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<DeleteInstituteResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Delete institute by ID

[src]

fn get_institute_by_id<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_id: Uuid,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<GetInstituteByIdResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Find institute by ID

[src]

fn get_institutes<'life0, 'life1, 'life2, 'async_trait>(
 &'life0 self,
 param_name: Option<String>,
 param_location_name: Option<String>,
 param_location_address: Option<String>,
 param_location_email: Option<String>,
 param_person_in_charge: Option<String>,
 param_sorts: Option<&'life1 Vec<InstituteSortCriteria>>,
 param_offset: Option<i32>,
 param_count: Option<i32>,
 context: &'life2 C
) -> Pin<Box<dyn Future<Output = Result<GetInstitutesResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 'life2: 'async_trait,
 Self: 'async_trait,

Get institutes

[src]

fn update_institute<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_id: Uuid,
 param_institute_mutation: InstituteMutation,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<UpdateInstituteResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Update an existing institute

[src]

fn add_parish<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_parish_mutation: Option<ParishMutation>,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<AddParishResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Add new parish

[src]

fn delete_parish<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_id: Uuid,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<DeleteParishResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Delete parish by ID

[src]

fn get_parish_by_id<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_id: Uuid,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<GetParishByIdResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Find parish by ID

[src]

fn get_parishes<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_deanery_id: Option<Uuid>,
 param_diocese_id: Option<Uuid>,
 param_name: Option<String>,
 param_offset: Option<i32>,
 param_count: Option<i32>,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<GetParishesResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Get all parishes

[src]

fn update_parish<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_id: Uuid,
 param_parish_mutation: Option<ParishMutation>,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<UpdateParishResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Update an existing parish

[src]

fn add_province<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_province_mutation: Option<ProvinceMutation>,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<AddProvinceResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Add new province

[src]

fn delete_province<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_id: Uuid,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<DeleteProvinceResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Delete province by ID

[src]

fn get_province_by_id<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_id: Uuid,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<GetProvinceByIdResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Find province by ID

[src]

fn get_provinces<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_name: Option<String>,
 param_province_code: Option<Code>,
 param_offset: Option<i32>,
 param_count: Option<i32>,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<GetProvincesResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Get all provinces

[src]

fn update_province<'life0, 'life1, 'async_trait>(
 &'life0 self,
 param_id: Uuid,
 param_province_mutation: Option<ProvinceMutation>,
 context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<UpdateProvinceResponse, ApiError>> + Send + 'async_trait>> where
 'life0: 'async_trait,
 'life1: 'async_trait,
 Self: 'async_trait,

Update an existing province

[src]

impl<S, C> Clone for Client<S, C> where
 S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static,
 S::Future: Send + 'static,
 S::Error: Into<Box<dyn Error + Send + Sync + 'static>> + Display,
 C: Clone + Send + Sync + 'static,

[src]

fn clone(&self) -> Self

Returns a copy of the value. Read more

1.0.0[src]

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

[src]

impl<S, C> Debug for Client<S, C> where
 S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static,
 S::Future: Send + 'static,
 S::Error: Into<Box<dyn Error + Send + Sync + 'static>> + Display,
 C: Clone + Send + Sync + 'static,

[src]

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Auto Trait Implementations

impl<S, C> RefUnwindSafe for Client<S, C> where
S: RefUnwindSafe,

impl<S, C> Send for Client<S, C>

impl<S, C> Sync for Client<S, C>

impl<S, C> Unpin for Client<S, C> where
S: Unpin,

impl<S, C> UnwindSafe for Client<S, C> where
S: UnwindSafe,

Blanket Implementations

[src]

impl<T> Any for T where
T: 'static + ?Sized,

[src]

pub fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

[src]

impl<T> Borrow<T> for T where
T: ?Sized,

[src]

pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

[src]

impl<T> BorrowMut<T> for T where
T: ?Sized,

[src]

pub fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

[src]

impl<T, C> ContextWrapperExt<C> for T where
T: Api<C> + Send + Sync,
C: Clone + Send + Sync,

[src]

pub fn with_context(Self, C) -> ContextWrapper<T, C>

Binds this API to a context.

[src]

impl<T> From<T> for T

[src]

pub fn from(t: T) -> T

Performs the conversion.

[src]

impl<T> Instrument for T

[src]

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

[src]

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

[src]

impl<T> Instrument for T

[src]

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

[src]

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

[src]

impl<T, U> Into for T where
U: From<T>,

[src]

pub fn into(self) -> U

Performs the conversion.

[src]

impl<T> ToOwned for T where
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

[src]

pub fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

[src]

pub fn clone_into(&self, target: &mut T)

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

[src]

impl<T, U> TryFrom for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

[src]

pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

[src]

impl<T, U> TryInto for T where
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

[src]

pub fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

[src]

impl<T> WithSubscriber for T

[src]

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

[src]

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

Struct hvcg_governance_openapi_catholic_polity::client::Client[−][src]

Implementations

impl<Connector, C> Client<DropContextService<Client<Connector, Body>, C>, C> where Connector: Connect + Clone + Send + Sync + 'static, C: Clone + Send + Sync + 'static,

pub fn try_new_with_connector( base_path: &str, protocol: Option<&'static str>, connector: Connector) -> Result<Self, ClientInitError>

impl<C> Client<DropContextService<HyperClient, C>, C> where C: Clone + Send + Sync + 'static,

pub fn try_new(base_path: &str) -> Result<Self, ClientInitError>

impl<C> Client<DropContextService<Client<HttpConnector, Body>, C>, C> where C: Clone + Send + Sync + 'static,

pub fn try_new_http(base_path: &str) -> Result<Self, ClientInitError>

impl<C> Client<DropContextService<Client<HttpsConnector<HttpConnector>, Body>, C>, C> where C: Clone + Send + Sync + 'static,

pub fn try_new_https(base_path: &str) -> Result<Self, ClientInitError>

impl<S, C> Client<S, C> where S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static, S::Future: Send + 'static, S::Error: Into<Box<dyn Error + Send + Sync + 'static>> + Display, C: Clone + Send + Sync + 'static,

pub fn try_new_with_client_service( client_service: S, base_path: &str) -> Result<Self, ClientInitError>

Trait Implementations

fn poll_ready( &self, cx: &mut Context<'_>) -> Poll<Result<(), Box<dyn Error + Send + Sync + 'static>>>

fn add_deanery<'life0, 'life1, 'async_trait>( &'life0 self, param_deanery_mutation: DeaneryMutation, context: &'life1 C) -> Pin<Box<dyn Future<Output = Result<AddDeaneryResponse, ApiError>> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn delete_deanery<'life0, 'life1, 'async_trait>( &'life0 self, param_id: Uuid, context: &'life1 C) -> Pin<Box<dyn Future<Output = Result<DeleteDeaneryResponse, ApiError>> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_deanery_by_id<'life0, 'life1, 'async_trait>( &'life0 self, param_id: Uuid, context: &'life1 C) -> Pin<Box<dyn Future<Output = Result<GetDeaneryByIdResponse, ApiError>> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn add_diocese<'life0, 'life1, 'async_trait>( &'life0 self, param_diocese_mutation: DioceseMutation, context: &'life1 C) -> Pin<Box<dyn Future<Output = Result<AddDioceseResponse, ApiError>> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn delete_diocese<'life0, 'life1, 'async_trait>( &'life0 self, param_id: Uuid, context: &'life1 C) -> Pin<Box<dyn Future<Output = Result<DeleteDioceseResponse, ApiError>> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_diocese_by_id<'life0, 'life1, 'async_trait>( &'life0 self, param_id: Uuid, context: &'life1 C) -> Pin<Box<dyn Future<Output = Result<GetDioceseByIdResponse, ApiError>> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn add_institute<'life0, 'life1, 'async_trait>( &'life0 self, param_institute_mutation: InstituteMutation, context: &'life1 C) -> Pin<Box<dyn Future<Output = Result<AddInstituteResponse, ApiError>> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn delete_institute<'life0, 'life1, 'async_trait>( &'life0 self, param_id: Uuid, context: &'life1 C) -> Pin<Box<dyn Future<Output = Result<DeleteInstituteResponse, ApiError>> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_institute_by_id<'life0, 'life1, 'async_trait>( &'life0 self, param_id: Uuid, context: &'life1 C) -> Pin<Box<dyn Future<Output = Result<GetInstituteByIdResponse, ApiError>> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn add_parish<'life0, 'life1, 'async_trait>( &'life0 self, param_parish_mutation: Option<ParishMutation>, context: &'life1 C) -> Pin<Box<dyn Future<Output = Result<AddParishResponse, ApiError>> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn delete_parish<'life0, 'life1, 'async_trait>( &'life0 self, param_id: Uuid, context: &'life1 C) -> Pin<Box<dyn Future<Output = Result<DeleteParishResponse, ApiError>> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_parish_by_id<'life0, 'life1, 'async_trait>( &'life0 self, param_id: Uuid, context: &'life1 C) -> Pin<Box<dyn Future<Output = Result<GetParishByIdResponse, ApiError>> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn add_province<'life0, 'life1, 'async_trait>( &'life0 self, param_province_mutation: Option<ProvinceMutation>, context: &'life1 C) -> Pin<Box<dyn Future<Output = Result<AddProvinceResponse, ApiError>> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn delete_province<'life0, 'life1, 'async_trait>( &'life0 self, param_id: Uuid, context: &'life1 C) -> Pin<Box<dyn Future<Output = Result<DeleteProvinceResponse, ApiError>> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_province_by_id<'life0, 'life1, 'async_trait>( &'life0 self, param_id: Uuid, context: &'life1 C) -> Pin<Box<dyn Future<Output = Result<GetProvinceByIdResponse, ApiError>> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

impl<S, C> Clone for Client<S, C> where S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static, S::Future: Send + 'static, S::Error: Into<Box<dyn Error + Send + Sync + 'static>> + Display, C: Clone + Send + Sync + 'static,

fn clone(&self) -> Self

fn clone_from(&mut self, source: &Self)

impl<S, C> Debug for Client<S, C> where S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static, S::Future: Send + 'static, S::Error: Into<Box<dyn Error + Send + Sync + 'static>> + Display, C: Clone + Send + Sync + 'static,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Auto Trait Implementations

impl<S, C> RefUnwindSafe for Client<S, C> where S: RefUnwindSafe,

impl<S, C> Send for Client<S, C>

impl<S, C> Sync for Client<S, C>

impl<S, C> Unpin for Client<S, C> where S: Unpin,

impl<S, C> UnwindSafe for Client<S, C> where S: UnwindSafe,

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized,

pub fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

pub fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T

impl<T, C> ContextWrapperExt<C> for T where T: Api<C> + Send + Sync, C: Clone + Send + Sync,

pub fn with_context(Self, C) -> ContextWrapper<T, C>

impl<T> From<T> for T

pub fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for T where U: From<T>,

pub fn into(self) -> U

impl<T> ToOwned for T where T: Clone,

type Owned = T

pub fn to_owned(&self) -> T

pub fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for T where U: Into<T>,

type Error = Infallible

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for T where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where S: Into<Dispatch>,

fn with_current_subscriber(self) -> WithDispatch<Self>

impl<Connector, C> Client<DropContextService<Client<Connector, Body>, C>, C> where
Connector: Connect + Clone + Send + Sync + 'static,
C: Clone + Send + Sync + 'static,

pub fn try_new_with_connector(
base_path: &str,
protocol: Option<&'static str>,
connector: Connector
) -> Result<Self, ClientInitError>

impl<C> Client<DropContextService<HyperClient, C>, C> where
C: Clone + Send + Sync + 'static,

impl<C> Client<DropContextService<Client<HttpConnector, Body>, C>, C> where
C: Clone + Send + Sync + 'static,

impl<C> Client<DropContextService<Client<HttpsConnector<HttpConnector>, Body>, C>, C> where
C: Clone + Send + Sync + 'static,

impl<S, C> Client<S, C> where
S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static,
S::Future: Send + 'static,
S::Error: Into<Box<dyn Error + Send + Sync + 'static>> + Display,
C: Clone + Send + Sync + 'static,

pub fn try_new_with_client_service(
client_service: S,
base_path: &str
) -> Result<Self, ClientInitError>

fn poll_ready(
&self,
cx: &mut Context<'_>
) -> Poll<Result<(), Box<dyn Error + Send + Sync + 'static>>>

fn add_deanery<'life0, 'life1, 'async_trait>(
&'life0 self,
param_deanery_mutation: DeaneryMutation,
context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<AddDeaneryResponse, ApiError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,

fn delete_deanery<'life0, 'life1, 'async_trait>(
&'life0 self,
param_id: Uuid,
context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<DeleteDeaneryResponse, ApiError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,

fn get_deanery_by_id<'life0, 'life1, 'async_trait>(
&'life0 self,
param_id: Uuid,
context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<GetDeaneryByIdResponse, ApiError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,

fn add_diocese<'life0, 'life1, 'async_trait>(
&'life0 self,
param_diocese_mutation: DioceseMutation,
context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<AddDioceseResponse, ApiError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,

fn delete_diocese<'life0, 'life1, 'async_trait>(
&'life0 self,
param_id: Uuid,
context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<DeleteDioceseResponse, ApiError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,

fn get_diocese_by_id<'life0, 'life1, 'async_trait>(
&'life0 self,
param_id: Uuid,
context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<GetDioceseByIdResponse, ApiError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,

fn add_institute<'life0, 'life1, 'async_trait>(
&'life0 self,
param_institute_mutation: InstituteMutation,
context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<AddInstituteResponse, ApiError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,

fn delete_institute<'life0, 'life1, 'async_trait>(
&'life0 self,
param_id: Uuid,
context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<DeleteInstituteResponse, ApiError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,

fn get_institute_by_id<'life0, 'life1, 'async_trait>(
&'life0 self,
param_id: Uuid,
context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<GetInstituteByIdResponse, ApiError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,

fn add_parish<'life0, 'life1, 'async_trait>(
&'life0 self,
param_parish_mutation: Option<ParishMutation>,
context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<AddParishResponse, ApiError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,

fn delete_parish<'life0, 'life1, 'async_trait>(
&'life0 self,
param_id: Uuid,
context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<DeleteParishResponse, ApiError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,

fn get_parish_by_id<'life0, 'life1, 'async_trait>(
&'life0 self,
param_id: Uuid,
context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<GetParishByIdResponse, ApiError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,

fn add_province<'life0, 'life1, 'async_trait>(
&'life0 self,
param_province_mutation: Option<ProvinceMutation>,
context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<AddProvinceResponse, ApiError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,

fn delete_province<'life0, 'life1, 'async_trait>(
&'life0 self,
param_id: Uuid,
context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<DeleteProvinceResponse, ApiError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,

fn get_province_by_id<'life0, 'life1, 'async_trait>(
&'life0 self,
param_id: Uuid,
context: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<GetProvinceByIdResponse, ApiError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,

impl<S, C> Clone for Client<S, C> where
S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static,
S::Future: Send + 'static,
S::Error: Into<Box<dyn Error + Send + Sync + 'static>> + Display,
C: Clone + Send + Sync + 'static,

impl<S, C> Debug for Client<S, C> where
S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static,
S::Future: Send + 'static,
S::Error: Into<Box<dyn Error + Send + Sync + 'static>> + Display,
C: Clone + Send + Sync + 'static,

impl<S, C> RefUnwindSafe for Client<S, C> where
S: RefUnwindSafe,

impl<S, C> Unpin for Client<S, C> where
S: Unpin,

impl<S, C> UnwindSafe for Client<S, C> where
S: UnwindSafe,

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

impl<T, C> ContextWrapperExt<C> for T where
T: Api<C> + Send + Sync,
C: Clone + Send + Sync,

impl<T, U> Into<U> for T where
U: From<T>,

impl<T> ToOwned for T where
T: Clone,

impl<T, U> TryFrom<U> for T where
U: Into<T>,

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,