Struct BoxCloneService

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

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;
#
# struct Request;
# struct Response;
# impl Response {
#     fn new() -> Self { Self }
# }

// 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())
    });
# let service = assert_service(service);

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

// And we can still clone the service
let cloned_service = service.clone();
#
# fn assert_service<S, R>(svc: S) -> S
# where S: Service<R> { svc }

Implementations

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

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.

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

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

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

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

type Response = U;
type Error = E;
type Future = Pin<Box<dyn Future<Output = Result<U, E>> + Send>>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), E>>
fn call(&mut self, request: T) -> Self::Future

Auto Trait Implementations

impl<T, U, E> !RefUnwindSafe for BoxCloneService<T, U, E>

impl<T, U, E> !Sync for BoxCloneService<T, U, E>

impl<T, U, E> !UnwindSafe for BoxCloneService<T, U, E>

impl<T, U, E> Freeze for BoxCloneService<T, U, E> where Box<dyn CloneService<T, Error = E, Future = Pin<Box<dyn Future<Output = Result<U, E>> + Send>>, Response = U> + Send>: Freeze,

impl<T, U, E> Send for BoxCloneService<T, U, E> where Box<dyn CloneService<T, Error = E, Future = Pin<Box<dyn Future<Output = Result<U, E>> + Send>>, Response = U> + Send>: Send,

impl<T, U, E> Unpin for BoxCloneService<T, U, E> where Box<dyn CloneService<T, Error = E, Future = Pin<Box<dyn Future<Output = Result<U, E>> + Send>>, Response = U> + Send>: Unpin,

impl<T, U, E> UnsafeUnpin for BoxCloneService<T, U, E> where Box<dyn CloneService<T, Error = E, Future = Pin<Box<dyn Future<Output = Result<U, E>> + Send>>, Response = U> + Send>: UnsafeUnpin,

Blanket Implementations

impl<C, Target> MakeConnection<Target> for BoxCloneService<T, U, E> where C: Service<Target>, <C as Service<Target>>::Response: AsyncRead + AsyncWrite,

type Connection = <C as Service<Target>>::Response;
type Error = <C as Service<Target>>::Error;
type Future = <C as Service<Target>>::Future;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), <C as MakeConnection<Target>>::Error>>
fn make_connection(&mut self, target: Target) -> <C as MakeConnection<Target>>::Future

impl<M, S, Target, Request> MakeService<Target, Request> for BoxCloneService<T, U, E> where M: Service<Target, Response = S>, S: Service<Request>,

type Response = <S as Service<Request>>::Response;
type Error = <S as Service<Request>>::Error;
type Service = S;
type MakeError = <M as Service<Target>>::Error;
type Future = <M as Service<Target>>::Future;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), <M as MakeService<Target, Request>>::MakeError>>
fn make_service(&mut self, target: Target) -> <M as MakeService<Target, Request>>::Future

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

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for BoxCloneService<T, U, E> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for BoxCloneService<T, U, E> where T: ?Sized,

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

impl<T> CloneToUninit for BoxCloneService<T, U, E> where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

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

fn from(t: T) -> T

Returns the argument unchanged.

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

impl<T> ToOwned for BoxCloneService<T, U, E> where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

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

impl<T, Request> ServiceExt<Request> for BoxCloneService<T, U, E> where T: Service<Request> + ?Sized,

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

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

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

type Error = never;
fn try_from(value: U) -> Result<T, never>

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

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