Struct 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>

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

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

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

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

type Service = BoxService<T, U, E>;
fn layer(&self, inner: In) -> Self::Service

Auto Trait Implementations

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

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

impl<In, T, U, E> Freeze for BoxLayer<In, T, U, E> where Arc<dyn Layer<In, Service = BoxService<T, U, E>> + Sync + Send>: Freeze,

impl<In, T, U, E> Send for BoxLayer<In, T, U, E> where Arc<dyn Layer<In, Service = BoxService<T, U, E>> + Sync + Send>: Send,

impl<In, T, U, E> Sync for BoxLayer<In, T, U, E> where Arc<dyn Layer<In, Service = BoxService<T, U, E>> + Sync + Send>: Sync,

impl<In, T, U, E> Unpin for BoxLayer<In, T, U, E> where Arc<dyn Layer<In, Service = BoxService<T, U, E>> + Sync + Send>: Unpin,

impl<In, T, U, E> UnsafeUnpin for BoxLayer<In, T, U, E> where Arc<dyn Layer<In, Service = BoxService<T, U, E>> + Sync + Send>: UnsafeUnpin,

Blanket Implementations

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

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

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

impl<T> From<T> 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> where T: Clone,

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

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

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

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

impl<T, U> TryInto<U> for BoxLayer<In, 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>