Trait ntex::service::Service [−][src]
An asynchronous function from Request
to a Response
.
Service
represents a service that represanting interation, taking requests and giving back
replies. You can think about service as a function with one argument and result as a return
type. In general form it looks like async fn(Req) -> Result<Res, Err>
. Service
trait just generalizing form of this function. Each parameter described as an assotiated type.
Services provides a symmetric and uniform API, same abstractions represents
clients and servers. Services describe only transforamtion
operation
which encorouge to simplify api surface and phrases value transformation
.
That leads to simplier design of each service. That also allows better testability
and better composition.
Services could be represented in several different forms. In general,
Service is a type that implements Service
trait.
struct MyService; impl Service for MyService { type Request = u8; type Response = u64; type Error = MyError; type Future = Pin<Box<Future<Output=Result<Self::Response, Self::Error>>>; fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { ... } fn call(&mut self, req: Self::Request) -> Self::Future { ... } }
Service can have mutable state that influence computation. This service could be rewritten as a simple function:
async fn my_service(req: u8) -> Result<u64, MyError>;
Associated Types
type Request
[src]
Requests handled by the service.
type Response
[src]
Responses given by the service.
type Error
[src]
Errors produced by the service.
type Future: Future
[src]
The future response value.
Required methods
pub fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
Returns Ready
when the service is able to process requests.
If the service is at capacity, then Pending
is returned and the task
is notified when the service becomes ready again. This function is
expected to be called while on a task.
This is a best effort implementation. False positives are permitted.
It is permitted for the service to return Ready
from a poll_ready
call and the next invocation of call
results in an error.
There are several notes to consider:
-
.poll_ready()
might be called on different task from actual service call. -
In case of chained services,
.poll_ready()
get called for all services at once.
pub fn call(&self, req: Self::Request) -> Self::Future
[src]
Process the request and return the response asynchronously.
This function is expected to be callable off task. As such,
implementations should take care to not call poll_ready
. If the
service is at capacity and the request is unable to be handled, the
returned Future
should resolve to an error.
Calling call
without calling poll_ready
is permitted. The
implementation must be resilient to this fact.
Provided methods
pub fn poll_shutdown(&self, ctx: &mut Context<'_>, is_error: bool) -> Poll<()>
[src]
Shutdown service.
Returns Ready
when the service is properly shutdowned. This method might be called
after it returns Ready
.
pub fn map<F, R>(self, f: F) -> Map<Self, F, R> where
F: FnMut(Self::Response) -> R,
[src]
F: FnMut(Self::Response) -> R,
Map this service's output to a different type, returning a new service of the resulting type.
This function is similar to the Option::map
or Iterator::map
where
it will change the type of the underlying service.
Note that this function consumes the receiving service and returns a
wrapped version of it, similar to the existing map
methods in the
standard library.
pub fn map_err<F, E>(self, f: F) -> MapErr<Self, F, E> where
F: Fn(Self::Error) -> E,
[src]
F: Fn(Self::Error) -> E,
Map this service's error to a different error, returning a new service.
This function is similar to the Result::map_err
where it will change
the error type of the underlying service. This is useful for example to
ensure that services have the same error type.
Note that this function consumes the receiving service and returns a wrapped version of it.
Implementations on Foreign Types
impl<S> Service for Box<S, Global> where
S: Service + ?Sized,
[src]
S: Service + ?Sized,
type Request = <S as Service>::Request
type Response = <S as Service>::Response
type Error = <S as Service>::Error
type Future = <S as Service>::Future
pub fn poll_ready(
&self,
cx: &mut Context<'_>
) -> Poll<Result<(), <S as Service>::Error>>
[src]
&self,
cx: &mut Context<'_>
) -> Poll<Result<(), <S as Service>::Error>>
pub fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()>
[src]
pub fn call(
&self,
request: <Box<S, Global> as Service>::Request
) -> <S as Service>::Future
[src]
&self,
request: <Box<S, Global> as Service>::Request
) -> <S as Service>::Future
impl<S> Service for Rc<S> where
S: Service,
[src]
S: Service,
type Request = <S as Service>::Request
type Response = <S as Service>::Response
type Error = <S as Service>::Error
type Future = <S as Service>::Future
pub fn poll_ready(
&self,
cx: &mut Context<'_>
) -> Poll<Result<(), <Rc<S> as Service>::Error>>
[src]
&self,
cx: &mut Context<'_>
) -> Poll<Result<(), <Rc<S> as Service>::Error>>
pub fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()>
[src]
pub fn call(
&self,
request: <Rc<S> as Service>::Request
) -> <S as Service>::Future
[src]
&self,
request: <Rc<S> as Service>::Request
) -> <S as Service>::Future
Implementors
impl Service for ExpectHandler
[src]
type Request = Request
type Response = Request
type Error = Error
type Future = Ready<Result<Self::Response, Self::Error>>
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn call(&self, req: Request) -> Self::Future
[src]
impl Service for LowResTimeService
[src]
type Request = ()
type Response = Instant
type Error = Infallible
type Future = Ready<Result<Self::Response, Self::Error>>
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn call(&self, _: ()) -> Self::Future
[src]
impl<A, F, E> Service for MapErr<A, F, E> where
F: Fn(<A as Service>::Error) -> E + Clone,
A: Service,
[src]
F: Fn(<A as Service>::Error) -> E + Clone,
A: Service,
type Request = <A as Service>::Request
type Response = <A as Service>::Response
type Error = E
type Future = MapErrFuture<A, F, E>
pub fn poll_ready(
&self,
cx: &mut Context<'_>
) -> Poll<Result<(), <MapErr<A, F, E> as Service>::Error>>
[src]
&self,
cx: &mut Context<'_>
) -> Poll<Result<(), <MapErr<A, F, E> as Service>::Error>>
pub fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()>
[src]
pub fn call(
&self,
req: <A as Service>::Request
) -> <MapErr<A, F, E> as Service>::Future
[src]
&self,
req: <A as Service>::Request
) -> <MapErr<A, F, E> as Service>::Future
impl<A, F, Response> Service for Map<A, F, Response> where
F: FnMut(<A as Service>::Response) -> Response + Clone,
A: Service,
[src]
F: FnMut(<A as Service>::Response) -> Response + Clone,
A: Service,
type Request = <A as Service>::Request
type Response = Response
type Error = <A as Service>::Error
type Future = MapFuture<A, F, Response>
pub fn poll_ready(
&self,
cx: &mut Context<'_>
) -> Poll<Result<(), <Map<A, F, Response> as Service>::Error>>
[src]
&self,
cx: &mut Context<'_>
) -> Poll<Result<(), <Map<A, F, Response> as Service>::Error>>
pub fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()>
[src]
pub fn call(
&self,
req: <A as Service>::Request
) -> <Map<A, F, Response> as Service>::Future
[src]
&self,
req: <A as Service>::Request
) -> <Map<A, F, Response> as Service>::Future
impl<F, Fut, Req, Res, Err> Service for FnMutService<F, Fut, Req, Res, Err> where
F: FnMut(Req) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
[src]
F: FnMut(Req) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
type Request = Req
type Response = Res
type Error = Err
type Future = Fut
pub fn poll_ready(
&self,
&mut Context<'_>
) -> Poll<Result<(), <FnMutService<F, Fut, Req, Res, Err> as Service>::Error>>
[src]
&self,
&mut Context<'_>
) -> Poll<Result<(), <FnMutService<F, Fut, Req, Res, Err> as Service>::Error>>
pub fn call(
&self,
req: Req
) -> <FnMutService<F, Fut, Req, Res, Err> as Service>::Future
[src]
&self,
req: Req
) -> <FnMutService<F, Fut, Req, Res, Err> as Service>::Future
impl<F, Fut, Req, Res, Err> Service for FnService<F, Fut, Req, Res, Err> where
F: Fn(Req) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
[src]
F: Fn(Req) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
type Request = Req
type Response = Res
type Error = Err
type Future = Fut
pub fn poll_ready(
&self,
&mut Context<'_>
) -> Poll<Result<(), <FnService<F, Fut, Req, Res, Err> as Service>::Error>>
[src]
&self,
&mut Context<'_>
) -> Poll<Result<(), <FnService<F, Fut, Req, Res, Err> as Service>::Error>>
pub fn call(
&self,
req: Req
) -> <FnService<F, Fut, Req, Res, Err> as Service>::Future
[src]
&self,
req: Req
) -> <FnService<F, Fut, Req, Res, Err> as Service>::Future
impl<F, Fut, Req, Res, Err> Service for FnServiceFactory<F, Fut, Req, Res, Err, ()> where
F: Fn(Req) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>,
[src]
F: Fn(Req) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>,
type Request = Req
type Response = Res
type Error = Err
type Future = Fut
pub fn poll_ready(
&self,
&mut Context<'_>
) -> Poll<Result<(), <FnServiceFactory<F, Fut, Req, Res, Err, ()> as Service>::Error>>
[src]
&self,
&mut Context<'_>
) -> Poll<Result<(), <FnServiceFactory<F, Fut, Req, Res, Err, ()> as Service>::Error>>
pub fn call(
&self,
req: <FnServiceFactory<F, Fut, Req, Res, Err, ()> as Service>::Request
) -> <FnServiceFactory<F, Fut, Req, Res, Err, ()> as Service>::Future
[src]
&self,
req: <FnServiceFactory<F, Fut, Req, Res, Err, ()> as Service>::Request
) -> <FnServiceFactory<F, Fut, Req, Res, Err, ()> as Service>::Future
impl<R, E, F> Service for KeepAliveService<R, E, F> where
F: Fn() -> E,
[src]
F: Fn() -> E,
type Request = R
type Response = R
type Error = E
type Future = Ready<Result<R, E>>
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn call(&self, req: R) -> Self::Future
[src]
impl<S> Service for TimeoutService<S> where
S: Service,
[src]
S: Service,
type Request = S::Request
type Response = S::Response
type Error = TimeoutError<S::Error>
type Future = Either<TimeoutServiceResponse<S>, TimeoutServiceResponse2<S>>
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()>
[src]
fn call(&self, request: S::Request) -> Self::Future
[src]
impl<S, E> Service for BufferService<S, E> where
S: Service<Error = E>,
[src]
S: Service<Error = E>,
type Request = S::Request
type Response = S::Response
type Error = S::Error
type Future = Either<S::Future, BufferServiceResponse<S, E>>
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()>
[src]
fn call(&self, req: S::Request) -> Self::Future
[src]
impl<T> Service for UpgradeHandler<T>
[src]
type Request = (Request, T, State, Codec)
type Response = ()
type Error = Error
type Future = Ready<Result<Self::Response, Self::Error>>
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn call(&self, _: Self::Request) -> Self::Future
[src]
impl<T> Service for ntex::server::openssl::AcceptorService<T> where
T: AsyncRead + AsyncWrite + Unpin + Debug + 'static,
[src]
T: AsyncRead + AsyncWrite + Unpin + Debug + 'static,
type Request = T
type Response = SslStream<T>
type Error = Box<dyn Error>
type Future = AcceptorServiceResponse<T>
fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn call(&self, req: Self::Request) -> Self::Future
[src]
impl<T> Service for Pipeline<T> where
T: Service,
[src]
T: Service,
type Request = <T as Service>::Request
type Response = <T as Service>::Response
type Error = <T as Service>::Error
type Future = <T as Service>::Future
pub fn poll_ready(
&self,
cx: &mut Context<'_>
) -> Poll<Result<(), <T as Service>::Error>>
[src]
&self,
cx: &mut Context<'_>
) -> Poll<Result<(), <T as Service>::Error>>
pub fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()>
[src]
pub fn call(
&self,
req: <T as Service>::Request
) -> <Pipeline<T> as Service>::Future
[src]
&self,
req: <T as Service>::Request
) -> <Pipeline<T> as Service>::Future
impl<T> Service for InFlightService<T> where
T: Service,
[src]
T: Service,
type Request = T::Request
type Response = T::Response
type Error = T::Error
type Future = InFlightServiceResponse<T>
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()>
[src]
fn call(&self, req: T::Request) -> Self::Future
[src]
impl<T, F, R, In, Out, Err> Service for Apply<T, F, R, In, Out, Err> where
T: Service<Error = Err>,
F: Fn(In, &T) -> R,
R: Future<Output = Result<Out, Err>>,
[src]
T: Service<Error = Err>,
F: Fn(In, &T) -> R,
R: Future<Output = Result<Out, Err>>,
type Request = In
type Response = Out
type Error = Err
type Future = R
pub fn poll_ready(
&self,
cx: &mut Context<'_>
) -> Poll<Result<(), <Apply<T, F, R, In, Out, Err> as Service>::Error>>
[src]
&self,
cx: &mut Context<'_>
) -> Poll<Result<(), <Apply<T, F, R, In, Out, Err> as Service>::Error>>
pub fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()>
[src]
pub fn call(&self, req: In) -> <Apply<T, F, R, In, Out, Err> as Service>::Future
[src]
impl<T, S, B, X, U> Service for H1ServiceHandler<T, S, B, X, U> where
T: AsyncRead + AsyncWrite + Unpin + 'static,
S: Service<Request = Request>,
S::Error: ResponseError + 'static,
S::Response: Into<Response<B>>,
B: MessageBody,
X: Service<Request = Request, Response = Request>,
X::Error: ResponseError + 'static,
U: Service<Request = (Request, T, IoState, Codec), Response = ()>,
U::Error: Display + Error + 'static,
[src]
T: AsyncRead + AsyncWrite + Unpin + 'static,
S: Service<Request = Request>,
S::Error: ResponseError + 'static,
S::Response: Into<Response<B>>,
B: MessageBody,
X: Service<Request = Request, Response = Request>,
X::Error: ResponseError + 'static,
U: Service<Request = (Request, T, IoState, Codec), Response = ()>,
U::Error: Display + Error + 'static,
type Request = (T, Option<SocketAddr>)
type Response = ()
type Error = DispatchError
type Future = Dispatcher<T, S, B, X, U>
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()>
[src]
fn call(&self, (io, addr): Self::Request) -> Self::Future
[src]
impl<T: AsyncRead + AsyncWrite + Unpin> Service for ntex::server::rustls::AcceptorService<T>
[src]
type Request = T
type Response = TlsStream<T>
type Error = Box<dyn Error>
type Future = AcceptorServiceFut<T>
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn call(&self, req: Self::Request) -> Self::Future
[src]
impl<T: Address + 'static> Service for OpensslConnector<T>
[src]
type Request = Connect<T>
type Response = SslStream<TcpStream>
type Error = ConnectError
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn call(&self, req: Connect<T>) -> Self::Future
[src]
impl<T: Address + 'static> Service for RustlsConnector<T>
[src]
type Request = Connect<T>
type Response = TlsStream<TcpStream>
type Error = ConnectError
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn call(&self, req: Connect<T>) -> Self::Future
[src]
impl<T: Address> Service for Connector<T>
[src]
type Request = Connect<T>
type Response = TcpStream
type Error = ConnectError
type Future = ConnectServiceResponse<T>
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn call(&self, req: Connect<T>) -> Self::Future
[src]
impl<T: Address> Service for Resolver<T>
[src]
type Request = Connect<T>
type Response = Connect<T>
type Error = ConnectError
type Future = Pin<Box<dyn Future<Output = Result<Connect<T>, Self::Error>>>>
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn call(&self, req: Connect<T>) -> Self::Future
[src]
impl<V1, V2> Service for VariantService2<V1, V2> where
V1: Service,
V2: Service<Response = V1::Response, Error = V1::Error>,
[src]
V1: Service,
V2: Service<Response = V1::Response, Error = V1::Error>,
type Request = Variant2<V1::Request, V2::Request>
type Response = V1::Response
type Error = V1::Error
type Future = ServiceResponse<V1::Future, V2::Future>
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()>
[src]
fn call(&self, req: Self::Request) -> Self::Future
[src]
impl<V1, V2, V3> Service for VariantService3<V1, V2, V3> where
V1: Service,
V2: Service<Response = V1::Response, Error = V1::Error>,
V3: Service<Response = V1::Response, Error = V1::Error>,
[src]
V1: Service,
V2: Service<Response = V1::Response, Error = V1::Error>,
V3: Service<Response = V1::Response, Error = V1::Error>,
type Request = Variant3<V1::Request, V2::Request, V3::Request>
type Response = V1::Response
type Error = V1::Error
type Future = ServiceResponse<V1::Future, V2::Future, V3::Future>
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()>
[src]
fn call(&self, req: Self::Request) -> Self::Future
[src]
impl<V1, V2, V3, V4> Service for VariantService4<V1, V2, V3, V4> where
V1: Service,
V2: Service<Response = V1::Response, Error = V1::Error>,
V3: Service<Response = V1::Response, Error = V1::Error>,
V4: Service<Response = V1::Response, Error = V1::Error>,
[src]
V1: Service,
V2: Service<Response = V1::Response, Error = V1::Error>,
V3: Service<Response = V1::Response, Error = V1::Error>,
V4: Service<Response = V1::Response, Error = V1::Error>,
type Request = Variant4<V1::Request, V2::Request, V3::Request, V4::Request>
type Response = V1::Response
type Error = V1::Error
type Future = ServiceResponse<V1::Future, V2::Future, V3::Future, V4::Future>
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()>
[src]
fn call(&self, req: Self::Request) -> Self::Future
[src]
impl<V1, V2, V3, V4, V5> Service for VariantService5<V1, V2, V3, V4, V5> where
V1: Service,
V2: Service<Response = V1::Response, Error = V1::Error>,
V3: Service<Response = V1::Response, Error = V1::Error>,
V4: Service<Response = V1::Response, Error = V1::Error>,
V5: Service<Response = V1::Response, Error = V1::Error>,
[src]
V1: Service,
V2: Service<Response = V1::Response, Error = V1::Error>,
V3: Service<Response = V1::Response, Error = V1::Error>,
V4: Service<Response = V1::Response, Error = V1::Error>,
V5: Service<Response = V1::Response, Error = V1::Error>,
type Request = Variant5<V1::Request, V2::Request, V3::Request, V4::Request, V5::Request>
type Response = V1::Response
type Error = V1::Error
type Future = ServiceResponse<V1::Future, V2::Future, V3::Future, V4::Future, V5::Future>
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()>
[src]
fn call(&self, req: Self::Request) -> Self::Future
[src]
impl<V1, V2, V3, V4, V5, V6> Service for VariantService6<V1, V2, V3, V4, V5, V6> where
V1: Service,
V2: Service<Response = V1::Response, Error = V1::Error>,
V3: Service<Response = V1::Response, Error = V1::Error>,
V4: Service<Response = V1::Response, Error = V1::Error>,
V5: Service<Response = V1::Response, Error = V1::Error>,
V6: Service<Response = V1::Response, Error = V1::Error>,
[src]
V1: Service,
V2: Service<Response = V1::Response, Error = V1::Error>,
V3: Service<Response = V1::Response, Error = V1::Error>,
V4: Service<Response = V1::Response, Error = V1::Error>,
V5: Service<Response = V1::Response, Error = V1::Error>,
V6: Service<Response = V1::Response, Error = V1::Error>,
type Request = Variant6<V1::Request, V2::Request, V3::Request, V4::Request, V5::Request, V6::Request>
type Response = V1::Response
type Error = V1::Error
type Future = ServiceResponse<V1::Future, V2::Future, V3::Future, V4::Future, V5::Future, V6::Future>
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()>
[src]
fn call(&self, req: Self::Request) -> Self::Future
[src]
impl<V1, V2, V3, V4, V5, V6, V7> Service for VariantService7<V1, V2, V3, V4, V5, V6, V7> where
V1: Service,
V2: Service<Response = V1::Response, Error = V1::Error>,
V3: Service<Response = V1::Response, Error = V1::Error>,
V4: Service<Response = V1::Response, Error = V1::Error>,
V5: Service<Response = V1::Response, Error = V1::Error>,
V6: Service<Response = V1::Response, Error = V1::Error>,
V7: Service<Response = V1::Response, Error = V1::Error>,
[src]
V1: Service,
V2: Service<Response = V1::Response, Error = V1::Error>,
V3: Service<Response = V1::Response, Error = V1::Error>,
V4: Service<Response = V1::Response, Error = V1::Error>,
V5: Service<Response = V1::Response, Error = V1::Error>,
V6: Service<Response = V1::Response, Error = V1::Error>,
V7: Service<Response = V1::Response, Error = V1::Error>,
type Request = Variant7<V1::Request, V2::Request, V3::Request, V4::Request, V5::Request, V6::Request, V7::Request>
type Response = V1::Response
type Error = V1::Error
type Future = ServiceResponse<V1::Future, V2::Future, V3::Future, V4::Future, V5::Future, V6::Future, V7::Future>
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
[src]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()>
[src]
fn call(&self, req: Self::Request) -> Self::Future
[src]
impl<V1, V2, V3, V4, V5, V6, V7, V8> Service for VariantService8<V1, V2, V3, V4, V5, V6, V7, V8> where
V1: Service,
V2: Service<Response = V1::Response, Error = V1::Error>,
V3: Service<Response = V1::Response, Error = V1::Error>,
V4: Service<Response = V1::Response, Error = V1::Error>,
V5: Service<Response = V1::Response, Error = V1::Error>,
V6: Service<Response = V1::Response, Error = V1::Error>,
V7: Service<Response = V1::Response, Error = V1::Error>,
V8: Service<Response = V1::Response, Error = V1::Error>,
[src]
V1: Service,
V2: Service<Response = V1::Response, Error = V1::Error>,
V3: Service<Response = V1::Response, Error = V1::Error>,
V4: Service<Response = V1::Response, Error = V1::Error>,
V5: Service<Response = V1::Response, Error = V1::Error>,
V6: Service<Response = V1::Response, Error = V1::Error>,
V7: Service<Response = V1::Response, Error = V1::Error>,
V8: Service<Response = V1::Response, Error = V1::Error>,