Struct `BoxCloneSyncServiceLayer`

struct BoxCloneSyncServiceLayer<In, T, U, E> { ... }

A Clone + Send + Sync boxed Layer.

BoxCloneSyncServiceLayer turns a layer into a trait object, allowing both the Layer itself and the output Service to be dynamic, while having consistent types.

This Layer produces BoxCloneSyncService instances erasing the type of the Service produced by the wrapped Layer.

This is similar to BoxCloneServiceLayer except the layer and resulting service implements Sync.

Example

BoxCloneSyncServiceLayer can, for example, be useful to create layers dynamically that otherwise wouldn't have the same types, when the underlying service must be clone and sync (for example, when building a Hyper connector). In this example, we include a Timeout layer only if an environment variable is set. We can use BoxCloneSyncServiceLayer to return a consistent type regardless of runtime configuration:

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

#
# struct Request;
# struct Response;
# impl Response {
#     fn new() -> Self { Self }
# }

fn common_layer<S, T>() -> BoxCloneSyncServiceLayer<S, T, S::Response, BoxError>
where
    S: Service<T> + Clone + Send + Sync + 'static,
    S::Future: Send + 'static,
    S::Error: Into<BoxError> + 'static,
{
    let builder = ServiceBuilder::new()
        .concurrency_limit(100);

    if std::env::var("SET_TIMEOUT").is_ok() {
        let layer = builder
            .timeout(Duration::from_secs(30))
            .into_inner();

        BoxCloneSyncServiceLayer::new(layer)
    } else {
        let layer = builder
            .map_err(Into::into)
            .into_inner();

        BoxCloneSyncServiceLayer::new(layer)
    }
}

// We can clone the layer (this is true of BoxLayer as well)
let boxed_clone_sync_layer = common_layer();

let cloned_sync_layer = boxed_clone_sync_layer.clone();

// Using the `BoxCloneSyncServiceLayer` we can create a `BoxCloneSyncService`
let service: BoxCloneSyncService<Request, Response, BoxError> = ServiceBuilder::new().layer(cloned_sync_layer)
     .service_fn(|req: Request| async {
        Ok::<_, BoxError>(Response::new())
    });

# 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<In, T, U, E> BoxCloneSyncServiceLayer<In, T, U, E>`

fn new<L>(inner_layer: L) -> Self where L: Layer<In> + Send + Sync + 'static, <L as >::Service: Service<T, Response = U, Error = E> + Send + Sync + Clone + 'static, <<L as >::Service as Service<T>>::Future: Send + 'static: Create a new BoxCloneSyncServiceLayer.

`impl<In, T, U, E> Clone for BoxCloneSyncServiceLayer<In, T, U, E>`

fn clone(self: &Self) -> Self

`impl<In, T, U, E> Debug for BoxCloneSyncServiceLayer<In, T, U, E>`

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

`impl<In, T, U, E> Freeze for BoxCloneSyncServiceLayer<In, T, U, E>`

`impl<In, T, U, E> Layer for BoxCloneSyncServiceLayer<In, T, U, E>`

fn layer(self: &Self, inner: In) -> <Self as >::Service

`impl<In, T, U, E> RefUnwindSafe for BoxCloneSyncServiceLayer<In, T, U, E>`

`impl<In, T, U, E> Send for BoxCloneSyncServiceLayer<In, T, U, E>`

`impl<In, T, U, E> Sync for BoxCloneSyncServiceLayer<In, T, U, E>`

`impl<In, T, U, E> Unpin for BoxCloneSyncServiceLayer<In, T, U, E>`

`impl<In, T, U, E> UnsafeUnpin for BoxCloneSyncServiceLayer<In, T, U, E>`

`impl<In, T, U, E> UnwindSafe for BoxCloneSyncServiceLayer<In, T, U, E>`

`impl<T> Any for BoxCloneSyncServiceLayer<In, T, U, E>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for BoxCloneSyncServiceLayer<In, T, U, E>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for BoxCloneSyncServiceLayer<In, T, U, E>`

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

`impl<T> CloneToUninit for BoxCloneSyncServiceLayer<In, T, U, E>`

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

`impl<T> From for BoxCloneSyncServiceLayer<In, T, U, E>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> Instrument for BoxCloneSyncServiceLayer<In, T, U, E>`

`impl<T> ToOwned for BoxCloneSyncServiceLayer<In, T, U, E>`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T> WithSubscriber for BoxCloneSyncServiceLayer<In, T, U, E>`

`impl<T, U> Into for BoxCloneSyncServiceLayer<In, T, U, E>`

fn into(self: 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 for BoxCloneSyncServiceLayer<In, T, U, E>`

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

`impl<T, U> TryInto for BoxCloneSyncServiceLayer<In, T, U, E>`

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