Struct tower::util::BoxCloneService

pub struct BoxCloneService<T, U, E>(/* private fields */);

A Clone + Send boxed Service.

BoxCloneService turns a service into a trait object, allowing the response future type to be dynamic, and allowing the service to be cloned.

This is similar to BoxService except the resulting service implements Clone.

Example

use tower::{Service, ServiceBuilder, BoxError, util::BoxCloneService};
use std::time::Duration;

// This service has a complex type that is hard to name
let service = ServiceBuilder::new()
    .map_request(|req| {
        println!("received request");
        req
    })
    .map_response(|res| {
        println!("response produced");
        res
    })
    .load_shed()
    .concurrency_limit(64)
    .timeout(Duration::from_secs(10))
    .service_fn(|req: Request| async {
        Ok::<_, BoxError>(Response::new())
    });

// `BoxCloneService` will erase the type so it's nameable
let service: BoxCloneService<Request, Response, BoxError> = BoxCloneService::new(service);

// And we can still clone the service
let cloned_service = service.clone();

Implementations

impl<T, U, E> BoxCloneService<T, U, E>

pub fn new<S>(inner: S) -> Self

where S: Service<T, Response = U, Error = E> + Clone + Send + 'static, S::Future: Send + 'static,

Create a new BoxCloneService.

pub fn layer<S>() -> LayerFn<fn(_: S) -> Self>

where S: Service<T, Response = U, Error = E> + Clone + Send + 'static, S::Future: Send + 'static,

Returns a Layer for wrapping a Service in a BoxCloneService middleware.

Trait Implementations

impl<T, U, E> Clone for BoxCloneService<T, U, E>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, U, E> Debug for BoxCloneService<T, U, E>

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

Formats the value using the given formatter.

impl<T, U, E> Service<T> for BoxCloneService<T, U, E>

type Response = U

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<U, E>> + Send>>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), E>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, request: T) -> Self::Future

Process the request and return the response asynchronously.