Type Alias noosphere_cli::render::SphereRenderJobId

pub type SphereRenderJobId = (Did, Cid);

A pairing of Did and Cid, suitable for uniquely identifying the work needed to render a specific sphere at a specific version, regardless of relative location in the graph

Trait Implementations

impl<F, Fut, Res, S, B> Handler<((),), S, B> for Fwhere F: FnOnce() -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, Res: IntoResponse, B: Send + 'static,

type Future = Pin<Box<dyn Future<Output = Response<UnsyncBoxBody<Bytes, Error>>> + Send, Global>>

The type of future calling this handler returns.

fn call( self, _req: Request<B>, _state: S ) -> <F as Handler<((),), S, B>>::Future

Call the handler with the given request.

fn layer<L, NewReqBody>(self, layer: L) -> Layered<L, Self, T, S, B, NewReqBody>where L: Layer<HandlerService<Self, T, S, B>> + Clone, <L as Layer<HandlerService<Self, T, S, B>>>::Service: Service<Request<NewReqBody>>,

Apply a [tower::Layer] to the handler.

fn with_state(self, state: S) -> HandlerService<Self, T, S, B>

Convert the handler into a [Service] by providing the state

impl<F, Fut, S, B, Res, M, T1> Handler<(M, T1), S, B> for Fwhere F: FnOnce(T1) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, B: Send + 'static, S: Send + Sync + 'static, Res: IntoResponse, T1: FromRequest<S, B, M> + Send,

type Future = Pin<Box<dyn Future<Output = Response<UnsyncBoxBody<Bytes, Error>>> + Send, Global>>

The type of future calling this handler returns.

fn call( self, req: Request<B>, state: S ) -> <F as Handler<(M, T1), S, B>>::Future

Call the handler with the given request.

fn layer<L, NewReqBody>(self, layer: L) -> Layered<L, Self, T, S, B, NewReqBody>where L: Layer<HandlerService<Self, T, S, B>> + Clone, <L as Layer<HandlerService<Self, T, S, B>>>::Service: Service<Request<NewReqBody>>,

Apply a [tower::Layer] to the handler.

fn with_state(self, state: S) -> HandlerService<Self, T, S, B>

Convert the handler into a [Service] by providing the state

impl<F, Fut, S, B, Res, M, T1, T2> Handler<(M, T1, T2), S, B> for Fwhere F: FnOnce(T1, T2) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, B: Send + 'static, S: Send + Sync + 'static, Res: IntoResponse, T1: FromRequestParts<S> + Send, T2: FromRequest<S, B, M> + Send,

type Future = Pin<Box<dyn Future<Output = Response<UnsyncBoxBody<Bytes, Error>>> + Send, Global>>

The type of future calling this handler returns.

fn call( self, req: Request<B>, state: S ) -> <F as Handler<(M, T1, T2), S, B>>::Future

Call the handler with the given request.

fn layer<L, NewReqBody>(self, layer: L) -> Layered<L, Self, T, S, B, NewReqBody>where L: Layer<HandlerService<Self, T, S, B>> + Clone, <L as Layer<HandlerService<Self, T, S, B>>>::Service: Service<Request<NewReqBody>>,

Apply a [tower::Layer] to the handler.

fn with_state(self, state: S) -> HandlerService<Self, T, S, B>

Convert the handler into a [Service] by providing the state

impl<F, Fut, S, B, Res, M, T1, T2, T3> Handler<(M, T1, T2, T3), S, B> for Fwhere F: FnOnce(T1, T2, T3) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, B: Send + 'static, S: Send + Sync + 'static, Res: IntoResponse, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequest<S, B, M> + Send,

type Future = Pin<Box<dyn Future<Output = Response<UnsyncBoxBody<Bytes, Error>>> + Send, Global>>

The type of future calling this handler returns.

fn call( self, req: Request<B>, state: S ) -> <F as Handler<(M, T1, T2, T3), S, B>>::Future

Call the handler with the given request.

fn layer<L, NewReqBody>(self, layer: L) -> Layered<L, Self, T, S, B, NewReqBody>where L: Layer<HandlerService<Self, T, S, B>> + Clone, <L as Layer<HandlerService<Self, T, S, B>>>::Service: Service<Request<NewReqBody>>,

Apply a [tower::Layer] to the handler.

fn with_state(self, state: S) -> HandlerService<Self, T, S, B>

Convert the handler into a [Service] by providing the state

impl<F, Fut, S, B, Res, M, T1, T2, T3, T4> Handler<(M, T1, T2, T3, T4), S, B> for Fwhere F: FnOnce(T1, T2, T3, T4) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, B: Send + 'static, S: Send + Sync + 'static, Res: IntoResponse, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequest<S, B, M> + Send,

type Future = Pin<Box<dyn Future<Output = Response<UnsyncBoxBody<Bytes, Error>>> + Send, Global>>

The type of future calling this handler returns.

fn call( self, req: Request<B>, state: S ) -> <F as Handler<(M, T1, T2, T3, T4), S, B>>::Future

Call the handler with the given request.

fn layer<L, NewReqBody>(self, layer: L) -> Layered<L, Self, T, S, B, NewReqBody>where L: Layer<HandlerService<Self, T, S, B>> + Clone, <L as Layer<HandlerService<Self, T, S, B>>>::Service: Service<Request<NewReqBody>>,

Apply a [tower::Layer] to the handler.

fn with_state(self, state: S) -> HandlerService<Self, T, S, B>

Convert the handler into a [Service] by providing the state

impl<F, Fut, S, B, Res, M, T1, T2, T3, T4, T5> Handler<(M, T1, T2, T3, T4, T5), S, B> for Fwhere F: FnOnce(T1, T2, T3, T4, T5) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, B: Send + 'static, S: Send + Sync + 'static, Res: IntoResponse, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequest<S, B, M> + Send,

type Future = Pin<Box<dyn Future<Output = Response<UnsyncBoxBody<Bytes, Error>>> + Send, Global>>

The type of future calling this handler returns.

fn call( self, req: Request<B>, state: S ) -> <F as Handler<(M, T1, T2, T3, T4, T5), S, B>>::Future

Call the handler with the given request.

fn layer<L, NewReqBody>(self, layer: L) -> Layered<L, Self, T, S, B, NewReqBody>where L: Layer<HandlerService<Self, T, S, B>> + Clone, <L as Layer<HandlerService<Self, T, S, B>>>::Service: Service<Request<NewReqBody>>,

Apply a [tower::Layer] to the handler.

fn with_state(self, state: S) -> HandlerService<Self, T, S, B>

Convert the handler into a [Service] by providing the state

impl<F, Fut, S, B, Res, M, T1, T2, T3, T4, T5, T6> Handler<(M, T1, T2, T3, T4, T5, T6), S, B> for Fwhere F: FnOnce(T1, T2, T3, T4, T5, T6) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, B: Send + 'static, S: Send + Sync + 'static, Res: IntoResponse, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequest<S, B, M> + Send,

type Future = Pin<Box<dyn Future<Output = Response<UnsyncBoxBody<Bytes, Error>>> + Send, Global>>

The type of future calling this handler returns.

fn call( self, req: Request<B>, state: S ) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6), S, B>>::Future

Call the handler with the given request.

fn layer<L, NewReqBody>(self, layer: L) -> Layered<L, Self, T, S, B, NewReqBody>where L: Layer<HandlerService<Self, T, S, B>> + Clone, <L as Layer<HandlerService<Self, T, S, B>>>::Service: Service<Request<NewReqBody>>,

Apply a [tower::Layer] to the handler.

fn with_state(self, state: S) -> HandlerService<Self, T, S, B>

Convert the handler into a [Service] by providing the state

impl<F, Fut, S, B, Res, M, T1, T2, T3, T4, T5, T6, T7> Handler<(M, T1, T2, T3, T4, T5, T6, T7), S, B> for Fwhere F: FnOnce(T1, T2, T3, T4, T5, T6, T7) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, B: Send + 'static, S: Send + Sync + 'static, Res: IntoResponse, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequest<S, B, M> + Send,

type Future = Pin<Box<dyn Future<Output = Response<UnsyncBoxBody<Bytes, Error>>> + Send, Global>>

The type of future calling this handler returns.

fn call( self, req: Request<B>, state: S ) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7), S, B>>::Future

Call the handler with the given request.

fn layer<L, NewReqBody>(self, layer: L) -> Layered<L, Self, T, S, B, NewReqBody>where L: Layer<HandlerService<Self, T, S, B>> + Clone, <L as Layer<HandlerService<Self, T, S, B>>>::Service: Service<Request<NewReqBody>>,

Apply a [tower::Layer] to the handler.

fn with_state(self, state: S) -> HandlerService<Self, T, S, B>

Convert the handler into a [Service] by providing the state

impl<F, Fut, S, B, Res, M, T1, T2, T3, T4, T5, T6, T7, T8> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S, B> for Fwhere F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, B: Send + 'static, S: Send + Sync + 'static, Res: IntoResponse, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequest<S, B, M> + Send,

type Future = Pin<Box<dyn Future<Output = Response<UnsyncBoxBody<Bytes, Error>>> + Send, Global>>

The type of future calling this handler returns.

fn call( self, req: Request<B>, state: S ) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S, B>>::Future

Call the handler with the given request.

fn layer<L, NewReqBody>(self, layer: L) -> Layered<L, Self, T, S, B, NewReqBody>where L: Layer<HandlerService<Self, T, S, B>> + Clone, <L as Layer<HandlerService<Self, T, S, B>>>::Service: Service<Request<NewReqBody>>,

Apply a [tower::Layer] to the handler.

fn with_state(self, state: S) -> HandlerService<Self, T, S, B>

Convert the handler into a [Service] by providing the state

impl<F, Fut, S, B, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S, B> for Fwhere F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, B: Send + 'static, S: Send + Sync + 'static, Res: IntoResponse, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequest<S, B, M> + Send,

type Future = Pin<Box<dyn Future<Output = Response<UnsyncBoxBody<Bytes, Error>>> + Send, Global>>

The type of future calling this handler returns.

fn call( self, req: Request<B>, state: S ) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S, B>>::Future

Call the handler with the given request.

fn layer<L, NewReqBody>(self, layer: L) -> Layered<L, Self, T, S, B, NewReqBody>where L: Layer<HandlerService<Self, T, S, B>> + Clone, <L as Layer<HandlerService<Self, T, S, B>>>::Service: Service<Request<NewReqBody>>,

Apply a [tower::Layer] to the handler.

fn with_state(self, state: S) -> HandlerService<Self, T, S, B>

Convert the handler into a [Service] by providing the state

impl<F, Fut, S, B, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S, B> for Fwhere F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, B: Send + 'static, S: Send + Sync + 'static, Res: IntoResponse, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequest<S, B, M> + Send,

type Future = Pin<Box<dyn Future<Output = Response<UnsyncBoxBody<Bytes, Error>>> + Send, Global>>

The type of future calling this handler returns.

fn call( self, req: Request<B>, state: S ) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S, B>>::Future

Call the handler with the given request.

fn layer<L, NewReqBody>(self, layer: L) -> Layered<L, Self, T, S, B, NewReqBody>where L: Layer<HandlerService<Self, T, S, B>> + Clone, <L as Layer<HandlerService<Self, T, S, B>>>::Service: Service<Request<NewReqBody>>,

Apply a [tower::Layer] to the handler.

fn with_state(self, state: S) -> HandlerService<Self, T, S, B>

Convert the handler into a [Service] by providing the state

impl<F, Fut, S, B, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S, B> for Fwhere F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, B: Send + 'static, S: Send + Sync + 'static, Res: IntoResponse, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequest<S, B, M> + Send,

type Future = Pin<Box<dyn Future<Output = Response<UnsyncBoxBody<Bytes, Error>>> + Send, Global>>

The type of future calling this handler returns.

fn call( self, req: Request<B>, state: S ) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S, B>>::Future

Call the handler with the given request.

fn layer<L, NewReqBody>(self, layer: L) -> Layered<L, Self, T, S, B, NewReqBody>where L: Layer<HandlerService<Self, T, S, B>> + Clone, <L as Layer<HandlerService<Self, T, S, B>>>::Service: Service<Request<NewReqBody>>,

Apply a [tower::Layer] to the handler.

fn with_state(self, state: S) -> HandlerService<Self, T, S, B>

Convert the handler into a [Service] by providing the state

impl<F, Fut, S, B, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S, B> for Fwhere F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, B: Send + 'static, S: Send + Sync + 'static, Res: IntoResponse, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequest<S, B, M> + Send,

type Future = Pin<Box<dyn Future<Output = Response<UnsyncBoxBody<Bytes, Error>>> + Send, Global>>

The type of future calling this handler returns.

fn call( self, req: Request<B>, state: S ) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S, B>>::Future

Call the handler with the given request.

fn layer<L, NewReqBody>(self, layer: L) -> Layered<L, Self, T, S, B, NewReqBody>where L: Layer<HandlerService<Self, T, S, B>> + Clone, <L as Layer<HandlerService<Self, T, S, B>>>::Service: Service<Request<NewReqBody>>,

Apply a [tower::Layer] to the handler.

fn with_state(self, state: S) -> HandlerService<Self, T, S, B>

Convert the handler into a [Service] by providing the state

impl<F, Fut, S, B, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S, B> for Fwhere F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, B: Send + 'static, S: Send + Sync + 'static, Res: IntoResponse, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequestParts<S> + Send, T13: FromRequest<S, B, M> + Send,

type Future = Pin<Box<dyn Future<Output = Response<UnsyncBoxBody<Bytes, Error>>> + Send, Global>>

The type of future calling this handler returns.

fn call( self, req: Request<B>, state: S ) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S, B>>::Future

Call the handler with the given request.

fn layer<L, NewReqBody>(self, layer: L) -> Layered<L, Self, T, S, B, NewReqBody>where L: Layer<HandlerService<Self, T, S, B>> + Clone, <L as Layer<HandlerService<Self, T, S, B>>>::Service: Service<Request<NewReqBody>>,

Apply a [tower::Layer] to the handler.

fn with_state(self, state: S) -> HandlerService<Self, T, S, B>

Convert the handler into a [Service] by providing the state

impl<F, Fut, S, B, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S, B> for Fwhere F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, B: Send + 'static, S: Send + Sync + 'static, Res: IntoResponse, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequestParts<S> + Send, T13: FromRequestParts<S> + Send, T14: FromRequest<S, B, M> + Send,

type Future = Pin<Box<dyn Future<Output = Response<UnsyncBoxBody<Bytes, Error>>> + Send, Global>>

The type of future calling this handler returns.

fn call( self, req: Request<B>, state: S ) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S, B>>::Future

Call the handler with the given request.

fn layer<L, NewReqBody>(self, layer: L) -> Layered<L, Self, T, S, B, NewReqBody>where L: Layer<HandlerService<Self, T, S, B>> + Clone, <L as Layer<HandlerService<Self, T, S, B>>>::Service: Service<Request<NewReqBody>>,

Apply a [tower::Layer] to the handler.

fn with_state(self, state: S) -> HandlerService<Self, T, S, B>

Convert the handler into a [Service] by providing the state

impl<F, Fut, S, B, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S, B> for Fwhere F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, B: Send + 'static, S: Send + Sync + 'static, Res: IntoResponse, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequestParts<S> + Send, T13: FromRequestParts<S> + Send, T14: FromRequestParts<S> + Send, T15: FromRequest<S, B, M> + Send,

type Future = Pin<Box<dyn Future<Output = Response<UnsyncBoxBody<Bytes, Error>>> + Send, Global>>

The type of future calling this handler returns.

fn call( self, req: Request<B>, state: S ) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S, B>>::Future

Call the handler with the given request.

fn layer<L, NewReqBody>(self, layer: L) -> Layered<L, Self, T, S, B, NewReqBody>where L: Layer<HandlerService<Self, T, S, B>> + Clone, <L as Layer<HandlerService<Self, T, S, B>>>::Service: Service<Request<NewReqBody>>,

Apply a [tower::Layer] to the handler.

fn with_state(self, state: S) -> HandlerService<Self, T, S, B>

Convert the handler into a [Service] by providing the state

impl<F, Fut, S, B, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S, B> for Fwhere F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> Fut + Clone + Send + 'static, Fut: Future<Output = Res> + Send, B: Send + 'static, S: Send + Sync + 'static, Res: IntoResponse, T1: FromRequestParts<S> + Send, T2: FromRequestParts<S> + Send, T3: FromRequestParts<S> + Send, T4: FromRequestParts<S> + Send, T5: FromRequestParts<S> + Send, T6: FromRequestParts<S> + Send, T7: FromRequestParts<S> + Send, T8: FromRequestParts<S> + Send, T9: FromRequestParts<S> + Send, T10: FromRequestParts<S> + Send, T11: FromRequestParts<S> + Send, T12: FromRequestParts<S> + Send, T13: FromRequestParts<S> + Send, T14: FromRequestParts<S> + Send, T15: FromRequestParts<S> + Send, T16: FromRequest<S, B, M> + Send,

type Future = Pin<Box<dyn Future<Output = Response<UnsyncBoxBody<Bytes, Error>>> + Send, Global>>

The type of future calling this handler returns.

fn call( self, req: Request<B>, state: S ) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S, B>>::Future

Call the handler with the given request.

fn layer<L, NewReqBody>(self, layer: L) -> Layered<L, Self, T, S, B, NewReqBody>where L: Layer<HandlerService<Self, T, S, B>> + Clone, <L as Layer<HandlerService<Self, T, S, B>>>::Service: Service<Request<NewReqBody>>,

Apply a [tower::Layer] to the handler.

fn with_state(self, state: S) -> HandlerService<Self, T, S, B>

Convert the handler into a [Service] by providing the state

impl<IT, A, FromA> MultiUnzip<(FromA,)> for ITwhere IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.

impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for ITwhere IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>,

fn multiunzip(self) -> (FromA, FromB)

Unzip this iterator into multiple collections.

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for ITwhere IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>,

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for ITwhere IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>, FromD: Default + Extend<D>,

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for ITwhere IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for ITwhere IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for ITwhere IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for ITwhere IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for ITwhere IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend<I>,

fn multiunzip( self ) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for ITwhere IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend<I>, FromJ: Default + Extend<J>,

fn multiunzip( self ) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for ITwhere IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend<I>, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,

fn multiunzip( self ) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for ITwhere IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend<I>, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,

fn multiunzip( self ) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

Unzip this iterator into multiple collections.