Struct `BoxLayer`

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

A boxed Layer trait object.

BoxLayer 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 BoxService instances erasing the type of the Service produced by the wrapped Layer.

Example

BoxLayer can, for example, be useful to create layers dynamically that otherwise wouldn't have the same types. In this example, we include a Timeout layer only if an environment variable is set. We can use BoxLayer to return a consistent type regardless of runtime configuration:

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

fn common_layer<S, T>() -> BoxLayer<S, T, S::Response, BoxError>
where
    S: Service<T> + Send + '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();

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

        BoxLayer::new(layer)
    }
}

Implementations

`impl<In, T, U, E> BoxLayer<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 + 'static, <<L as >::Service as Service<T>>::Future: Send + 'static: Create a new BoxLayer.

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

fn clone(self: &Self) -> Self

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

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

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

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

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

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

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

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

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

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

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

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

fn type_id(self: &Self) -> TypeId

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

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

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

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

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

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

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

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

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

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

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

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

`impl<T, U> Into for BoxLayer<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 BoxLayer<In, T, U, E>`

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

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

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