Struct tower::util::BoxLayer

pub struct BoxLayer<In, T, U, E> { /* private fields */ }

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>

pub fn new<L>(inner_layer: L) -> Self

where L: Layer<In> + Send + Sync + 'static, L::Service: Service<T, Response = U, Error = E> + Send + 'static, <L::Service as Service<T>>::Future: Send + 'static,

Create a new BoxLayer.

Trait Implementations

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

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

Formats the value using the given formatter.

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

type Service = BoxService<T, U, E>

The wrapped service

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

Wrap the given service with the middleware, returning a new service that has been decorated with the middleware.