Trait actix_service::Service

source · 
pub trait Service<Request> {
    type Response;
    type Error;
    type Future: Future<Item = Self::Response, Error = Self::Error>;

    fn poll_ready(&mut self) -> Poll<(), Self::Error>;
    fn call(&mut self, req: Request) -> Self::Future;

    fn apply<T, I, F, Out, Req>(
        self,
        service: I,
        f: F
    ) -> AndThen<Self, Apply<T, F, Self::Response, Out, Req>>
    where
        Self: Sized,
        T: Service<Req, Error = Self::Error>,
        I: IntoService<T, Req>,
        F: Fn(Self::Response, &mut T) -> Out,
        Out: IntoFuture<Error = Self::Error>,
    { ... }
    fn and_then<F, B>(self, service: F) -> AndThen<Self, B>
    where
        Self: Sized,
        F: IntoService<B, Self::Response>,
        B: Service<Self::Response, Error = Self::Error>,
    { ... }
    fn from_err<E>(self) -> FromErr<Self, E>
    where
        Self: Sized,
        E: From<Self::Error>,
    { ... }
    fn then<B>(self, service: B) -> Then<Self, B>
    where
        Self: Sized,
        B: Service<Result<Self::Response, Self::Error>, Error = Self::Error>,
    { ... }
    fn map<F, R>(self, f: F) -> Map<Self, F, R>
    where
        Self: Sized,
        F: Fn(Self::Response) -> R,
    { ... }
    fn map_err<F, E>(self, f: F) -> MapErr<Self, F, E>
    where
        Self: Sized,
        F: Fn(Self::Error) -> E,
    { ... }
}
Expand description

An asynchronous function from Request to a Response.

Required Associated Types§

Responses given by the service.

Errors produced by the service.

The future response value.

Required Methods§

Returns Ready when the service is able to process requests.

If the service is at capacity, then NotReady 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.

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§

Apply function to specified service and use it as a next service in chain.

Call another service after call to this one has resolved successfully.

This function can be used to chain two services together and ensure that the second service isn’t called until call to the fist service have finished. Result of the call to the first service is used as an input parameter for the second service’s call.

Note that this function consumes the receiving service and returns a wrapped version of it.

Map this service’s error to any error implementing From for this services Error`.

Note that this function consumes the receiving service and returns a wrapped version of it.

Chain on a computation for when a call to the service finished, passing the result of the call to the next service B.

Note that this function consumes the receiving service and returns a wrapped version of it.

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.

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§

Implementors§