TaskFn

apalis_core::task_fn

Struct TaskFn 

Source 
pub struct TaskFn<F, Args, Ctx, FnArgs> { /* private fields */ }
Expand description

An executable service implemented by a closure.

See task_fn for more details.

Trait Implementations§

Source§

impl<T: Clone, Args, Ctx, FnArgs> Clone for TaskFn<T, Args, Ctx, FnArgs>

Source§

fn clone(&self) -> Self

Returns a duplicate of the value. Read more
1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl<T, Args, Ctx, FnArgs> Debug for TaskFn<T, Args, Ctx, FnArgs>

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<T, Args, Ctx, F, R, B, A1, A2> IntoWorkerService<B, TaskFn<T, Args, Ctx, (A1, A2)>, Args, Ctx> for T
where B: Backend<Args = Args, Context = Ctx>, T: FnMut(Args, A1, A2) -> F + Send + Clone + 'static, F: Future + Send, Args: Send + 'static, Ctx: Send + Sync + 'static, B::IdType: Send + 'static, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync,

Source§

fn into_service(self, _: &B) -> TaskFn<T, Args, Ctx, (A1, A2)>

Build the service from the backend
Source§

impl<T, Args, Ctx, F, R, B, A1, A2, A3> IntoWorkerService<B, TaskFn<T, Args, Ctx, (A1, A2, A3)>, Args, Ctx> for T
where B: Backend<Args = Args, Context = Ctx>, T: FnMut(Args, A1, A2, A3) -> F + Send + Clone + 'static, F: Future + Send, Args: Send + 'static, Ctx: Send + Sync + 'static, B::IdType: Send + 'static, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync,

Source§

fn into_service(self, _: &B) -> TaskFn<T, Args, Ctx, (A1, A2, A3)>

Build the service from the backend
Source§

impl<T, Args, Ctx, F, R, B, A1, A2, A3, A4> IntoWorkerService<B, TaskFn<T, Args, Ctx, (A1, A2, A3, A4)>, Args, Ctx> for T
where B: Backend<Args = Args, Context = Ctx>, T: FnMut(Args, A1, A2, A3, A4) -> F + Send + Clone + 'static, F: Future + Send, Args: Send + 'static, Ctx: Send + Sync + 'static, B::IdType: Send + 'static, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync,

Source§

fn into_service(self, _: &B) -> TaskFn<T, Args, Ctx, (A1, A2, A3, A4)>

Build the service from the backend
Source§

impl<T, Args, Ctx, F, R, B, A1, A2, A3, A4, A5> IntoWorkerService<B, TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5)>, Args, Ctx> for T
where B: Backend<Args = Args, Context = Ctx>, T: FnMut(Args, A1, A2, A3, A4, A5) -> F + Send + Clone + 'static, F: Future + Send, Args: Send + 'static, Ctx: Send + Sync + 'static, B::IdType: Send + 'static, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync,

Source§

fn into_service(self, _: &B) -> TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5)>

Build the service from the backend
Source§

impl<T, Args, Ctx, F, R, B, A1, A2, A3, A4, A5, A6> IntoWorkerService<B, TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6)>, Args, Ctx> for T
where B: Backend<Args = Args, Context = Ctx>, T: FnMut(Args, A1, A2, A3, A4, A5, A6) -> F + Send + Clone + 'static, F: Future + Send, Args: Send + 'static, Ctx: Send + Sync + 'static, B::IdType: Send + 'static, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync,

Source§

fn into_service(self, _: &B) -> TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6)>

Build the service from the backend
Source§

impl<T, Args, Ctx, F, R, B, A1, A2, A3, A4, A5, A6, A7> IntoWorkerService<B, TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7)>, Args, Ctx> for T
where B: Backend<Args = Args, Context = Ctx>, T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7) -> F + Send + Clone + 'static, F: Future + Send, Args: Send + 'static, Ctx: Send + Sync + 'static, B::IdType: Send + 'static, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync,

Source§

fn into_service( self, _: &B, ) -> TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7)>

Build the service from the backend
Source§

impl<T, Args, Ctx, F, R, B, A1, A2, A3, A4, A5, A6, A7, A8> IntoWorkerService<B, TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8)>, Args, Ctx> for T
where B: Backend<Args = Args, Context = Ctx>, T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7, A8) -> F + Send + Clone + 'static, F: Future + Send, Args: Send + 'static, Ctx: Send + Sync + 'static, B::IdType: Send + 'static, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A8 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync,

Source§

fn into_service( self, _: &B, ) -> TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8)>

Build the service from the backend
Source§

impl<T, Args, Ctx, F, R, B, A1, A2, A3, A4, A5, A6, A7, A8, A9> IntoWorkerService<B, TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9)>, Args, Ctx> for T
where B: Backend<Args = Args, Context = Ctx>, T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7, A8, A9) -> F + Send + Clone + 'static, F: Future + Send, Args: Send + 'static, Ctx: Send + Sync + 'static, B::IdType: Send + 'static, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A8 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A9 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync,

Source§

fn into_service( self, _: &B, ) -> TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9)>

Build the service from the backend
Source§

impl<T, Args, Ctx, F, R, B, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> IntoWorkerService<B, TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>, Args, Ctx> for T
where B: Backend<Args = Args, Context = Ctx>, T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) -> F + Send + Clone + 'static, F: Future + Send, Args: Send + 'static, Ctx: Send + Sync + 'static, B::IdType: Send + 'static, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A8 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A9 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A10 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync,

Source§

fn into_service( self, _: &B, ) -> TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>

Build the service from the backend
Source§

impl<T, Args, Ctx, F, R, B, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> IntoWorkerService<B, TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)>, Args, Ctx> for T
where B: Backend<Args = Args, Context = Ctx>, T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) -> F + Send + Clone + 'static, F: Future + Send, Args: Send + 'static, Ctx: Send + Sync + 'static, B::IdType: Send + 'static, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A8 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A9 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A10 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A11: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A11 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync,

Source§

fn into_service( self, _: &B, ) -> TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)>

Build the service from the backend
Source§

impl<T, Args, Ctx, F, R, B, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> IntoWorkerService<B, TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)>, Args, Ctx> for T
where B: Backend<Args = Args, Context = Ctx>, T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) -> F + Send + Clone + 'static, F: Future + Send, Args: Send + 'static, Ctx: Send + Sync + 'static, B::IdType: Send + 'static, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A8 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A9 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A10 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A11: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A11 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A12: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A12 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync,

Source§

fn into_service( self, _: &B, ) -> TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)>

Build the service from the backend
Source§

impl<T, Args, Ctx, F, R, B, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> IntoWorkerService<B, TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)>, Args, Ctx> for T
where B: Backend<Args = Args, Context = Ctx>, T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) -> F + Send + Clone + 'static, F: Future + Send, Args: Send + 'static, Ctx: Send + Sync + 'static, B::IdType: Send + 'static, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A8 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A9 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A10 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A11: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A11 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A12: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A12 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A13: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A13 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync,

Source§

fn into_service( self, _: &B, ) -> TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)>

Build the service from the backend
Source§

impl<T, Args, Ctx, F, R, B, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> IntoWorkerService<B, TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)>, Args, Ctx> for T
where B: Backend<Args = Args, Context = Ctx>, T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) -> F + Send + Clone + 'static, F: Future + Send, Args: Send + 'static, Ctx: Send + Sync + 'static, B::IdType: Send + 'static, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A8 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A9 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A10 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A11: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A11 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A12: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A12 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A13: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A13 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A14: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A14 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync,

Source§

fn into_service( self, _: &B, ) -> TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)>

Build the service from the backend
Source§

impl<T, Args, Ctx, F, R, B, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> IntoWorkerService<B, TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)>, Args, Ctx> for T
where B: Backend<Args = Args, Context = Ctx>, T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) -> F + Send + Clone + 'static, F: Future + Send, Args: Send + 'static, Ctx: Send + Sync + 'static, B::IdType: Send + 'static, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A8 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A9 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A10 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A11: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A11 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A12: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A12 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A13: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A13 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A14: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A14 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A15: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A15 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync,

Source§

fn into_service( self, _: &B, ) -> TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)>

Build the service from the backend
Source§

impl<T, Args, Ctx, F, R, B, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> IntoWorkerService<B, TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)>, Args, Ctx> for T
where B: Backend<Args = Args, Context = Ctx>, T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) -> F + Send + Clone + 'static, F: Future + Send, Args: Send + 'static, Ctx: Send + Sync + 'static, B::IdType: Send + 'static, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A8 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A9 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A10 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A11: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A11 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A12: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A12 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A13: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A13 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A14: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A14 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A15: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A15 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync, A16: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A16 as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync,

Source§

fn into_service( self, _: &B, ) -> TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)>

Build the service from the backend
Source§

impl<T, Args, Ctx, F, R, B, A> IntoWorkerService<B, TaskFn<T, Args, Ctx, A>, Args, Ctx> for T
where B: Backend<Args = Args, Context = Ctx>, T: FnMut(Args, A) -> F + Send + Clone + 'static, F: Future + Send, Args: Send + 'static, Ctx: Send + Sync + 'static, B::IdType: Send + 'static, F::Output: IntoResponse<Output = R>, A: FromRequest<Task<Args, Ctx, B::IdType>> + Send, <A as FromRequest<Task<Args, Ctx, B::IdType>>>::Error: Error + 'static + Send + Sync,

Source§

fn into_service(self, _: &B) -> TaskFn<T, Args, Ctx, A>

Build the service from the backend
Source§

impl<T, Args, Ctx, F, R, Backend> IntoWorkerService<Backend, TaskFn<T, Args, Ctx, ()>, Args, Ctx> for T
where T: FnMut(Args) -> F, F: Future, F::Output: IntoResponse<Output = R>, Backend: Backend<Args = Args, Context = Ctx>, Args: Send,

Source§

fn into_service(self, _: &Backend) -> TaskFn<T, Args, Ctx, ()>

Build the service from the backend
Source§

impl<T, F, Args, R, Ctx, IdType> Service<Task<Args, Ctx, IdType>> for TaskFn<T, Args, Ctx, ()>
where T: FnMut(Args) -> F, F: Future, F::Output: IntoResponse<Output = R>,

Source§

type Response = R

Responses given by the service.
Source§

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.
Source§

type Future = Map<F, fn(<F as Future>::Output) -> Result<R, Box<dyn Error + Send + Sync>>>

The future response value.
Source§

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Source§

fn call(&mut self, task: Task<Args, Ctx, IdType>) -> Self::Future

Process the request and return the response asynchronously. Read more
Source§

impl<T, F, Args: Send + 'static, R, Ctx: Send + 'static, IdType: Send + Clone + 'static, A1, A2> Service<Task<Args, Ctx, IdType>> for TaskFn<T, Args, Ctx, (A1, A2)>
where T: FnMut(Args, A1, A2) -> F + Send + Clone + 'static, F: Future + Send, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync,

Source§

type Response = R

Responses given by the service.
Source§

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.
Source§

type Future = Pin<Box<dyn Future<Output = Result<R, Box<dyn Error + Send + Sync>>> + Send>>

The future response value.
Source§

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Source§

fn call(&mut self, task: Task<Args, Ctx, IdType>) -> Self::Future

Process the request and return the response asynchronously. Read more
Source§

impl<T, F, Args: Send + 'static, R, Ctx: Send + 'static, IdType: Send + Clone + 'static, A1, A2, A3> Service<Task<Args, Ctx, IdType>> for TaskFn<T, Args, Ctx, (A1, A2, A3)>
where T: FnMut(Args, A1, A2, A3) -> F + Send + Clone + 'static, F: Future + Send, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync,

Source§

type Response = R

Responses given by the service.
Source§

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.
Source§

type Future = Pin<Box<dyn Future<Output = Result<R, Box<dyn Error + Send + Sync>>> + Send>>

The future response value.
Source§

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Source§

fn call(&mut self, task: Task<Args, Ctx, IdType>) -> Self::Future

Process the request and return the response asynchronously. Read more
Source§

impl<T, F, Args: Send + 'static, R, Ctx: Send + 'static, IdType: Send + Clone + 'static, A1, A2, A3, A4> Service<Task<Args, Ctx, IdType>> for TaskFn<T, Args, Ctx, (A1, A2, A3, A4)>
where T: FnMut(Args, A1, A2, A3, A4) -> F + Send + Clone + 'static, F: Future + Send, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync,

Source§

type Response = R

Responses given by the service.
Source§

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.
Source§

type Future = Pin<Box<dyn Future<Output = Result<R, Box<dyn Error + Send + Sync>>> + Send>>

The future response value.
Source§

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Source§

fn call(&mut self, task: Task<Args, Ctx, IdType>) -> Self::Future

Process the request and return the response asynchronously. Read more
Source§

impl<T, F, Args: Send + 'static, R, Ctx: Send + 'static, IdType: Send + Clone + 'static, A1, A2, A3, A4, A5> Service<Task<Args, Ctx, IdType>> for TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5)>
where T: FnMut(Args, A1, A2, A3, A4, A5) -> F + Send + Clone + 'static, F: Future + Send, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync,

Source§

type Response = R

Responses given by the service.
Source§

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.
Source§

type Future = Pin<Box<dyn Future<Output = Result<R, Box<dyn Error + Send + Sync>>> + Send>>

The future response value.
Source§

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Source§

fn call(&mut self, task: Task<Args, Ctx, IdType>) -> Self::Future

Process the request and return the response asynchronously. Read more
Source§

impl<T, F, Args: Send + 'static, R, Ctx: Send + 'static, IdType: Send + Clone + 'static, A1, A2, A3, A4, A5, A6> Service<Task<Args, Ctx, IdType>> for TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6)>
where T: FnMut(Args, A1, A2, A3, A4, A5, A6) -> F + Send + Clone + 'static, F: Future + Send, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync,

Source§

type Response = R

Responses given by the service.
Source§

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.
Source§

type Future = Pin<Box<dyn Future<Output = Result<R, Box<dyn Error + Send + Sync>>> + Send>>

The future response value.
Source§

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Source§

fn call(&mut self, task: Task<Args, Ctx, IdType>) -> Self::Future

Process the request and return the response asynchronously. Read more
Source§

impl<T, F, Args: Send + 'static, R, Ctx: Send + 'static, IdType: Send + Clone + 'static, A1, A2, A3, A4, A5, A6, A7> Service<Task<Args, Ctx, IdType>> for TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7)>
where T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7) -> F + Send + Clone + 'static, F: Future + Send, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync,

Source§

type Response = R

Responses given by the service.
Source§

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.
Source§

type Future = Pin<Box<dyn Future<Output = Result<R, Box<dyn Error + Send + Sync>>> + Send>>

The future response value.
Source§

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Source§

fn call(&mut self, task: Task<Args, Ctx, IdType>) -> Self::Future

Process the request and return the response asynchronously. Read more
Source§

impl<T, F, Args: Send + 'static, R, Ctx: Send + 'static, IdType: Send + Clone + 'static, A1, A2, A3, A4, A5, A6, A7, A8> Service<Task<Args, Ctx, IdType>> for TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8)>
where T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7, A8) -> F + Send + Clone + 'static, F: Future + Send, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args, Ctx, IdType>> + Send, <A8 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync,

Source§

type Response = R

Responses given by the service.
Source§

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.
Source§

type Future = Pin<Box<dyn Future<Output = Result<R, Box<dyn Error + Send + Sync>>> + Send>>

The future response value.
Source§

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Source§

fn call(&mut self, task: Task<Args, Ctx, IdType>) -> Self::Future

Process the request and return the response asynchronously. Read more
Source§

impl<T, F, Args: Send + 'static, R, Ctx: Send + 'static, IdType: Send + Clone + 'static, A1, A2, A3, A4, A5, A6, A7, A8, A9> Service<Task<Args, Ctx, IdType>> for TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9)>
where T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7, A8, A9) -> F + Send + Clone + 'static, F: Future + Send, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args, Ctx, IdType>> + Send, <A8 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args, Ctx, IdType>> + Send, <A9 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync,

Source§

type Response = R

Responses given by the service.
Source§

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.
Source§

type Future = Pin<Box<dyn Future<Output = Result<R, Box<dyn Error + Send + Sync>>> + Send>>

The future response value.
Source§

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Source§

fn call(&mut self, task: Task<Args, Ctx, IdType>) -> Self::Future

Process the request and return the response asynchronously. Read more
Source§

impl<T, F, Args: Send + 'static, R, Ctx: Send + 'static, IdType: Send + Clone + 'static, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> Service<Task<Args, Ctx, IdType>> for TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
where T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) -> F + Send + Clone + 'static, F: Future + Send, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args, Ctx, IdType>> + Send, <A8 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args, Ctx, IdType>> + Send, <A9 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args, Ctx, IdType>> + Send, <A10 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync,

Source§

type Response = R

Responses given by the service.
Source§

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.
Source§

type Future = Pin<Box<dyn Future<Output = Result<R, Box<dyn Error + Send + Sync>>> + Send>>

The future response value.
Source§

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Source§

fn call(&mut self, task: Task<Args, Ctx, IdType>) -> Self::Future

Process the request and return the response asynchronously. Read more
Source§

impl<T, F, Args: Send + 'static, R, Ctx: Send + 'static, IdType: Send + Clone + 'static, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> Service<Task<Args, Ctx, IdType>> for TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)>
where T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) -> F + Send + Clone + 'static, F: Future + Send, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args, Ctx, IdType>> + Send, <A8 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args, Ctx, IdType>> + Send, <A9 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args, Ctx, IdType>> + Send, <A10 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A11: FromRequest<Task<Args, Ctx, IdType>> + Send, <A11 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync,

Source§

type Response = R

Responses given by the service.
Source§

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.
Source§

type Future = Pin<Box<dyn Future<Output = Result<R, Box<dyn Error + Send + Sync>>> + Send>>

The future response value.
Source§

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Source§

fn call(&mut self, task: Task<Args, Ctx, IdType>) -> Self::Future

Process the request and return the response asynchronously. Read more
Source§

impl<T, F, Args: Send + 'static, R, Ctx: Send + 'static, IdType: Send + Clone + 'static, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> Service<Task<Args, Ctx, IdType>> for TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)>
where T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) -> F + Send + Clone + 'static, F: Future + Send, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args, Ctx, IdType>> + Send, <A8 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args, Ctx, IdType>> + Send, <A9 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args, Ctx, IdType>> + Send, <A10 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A11: FromRequest<Task<Args, Ctx, IdType>> + Send, <A11 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A12: FromRequest<Task<Args, Ctx, IdType>> + Send, <A12 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync,

Source§

type Response = R

Responses given by the service.
Source§

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.
Source§

type Future = Pin<Box<dyn Future<Output = Result<R, Box<dyn Error + Send + Sync>>> + Send>>

The future response value.
Source§

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Source§

fn call(&mut self, task: Task<Args, Ctx, IdType>) -> Self::Future

Process the request and return the response asynchronously. Read more
Source§

impl<T, F, Args: Send + 'static, R, Ctx: Send + 'static, IdType: Send + Clone + 'static, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> Service<Task<Args, Ctx, IdType>> for TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)>
where T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) -> F + Send + Clone + 'static, F: Future + Send, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args, Ctx, IdType>> + Send, <A8 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args, Ctx, IdType>> + Send, <A9 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args, Ctx, IdType>> + Send, <A10 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A11: FromRequest<Task<Args, Ctx, IdType>> + Send, <A11 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A12: FromRequest<Task<Args, Ctx, IdType>> + Send, <A12 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A13: FromRequest<Task<Args, Ctx, IdType>> + Send, <A13 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync,

Source§

type Response = R

Responses given by the service.
Source§

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.
Source§

type Future = Pin<Box<dyn Future<Output = Result<R, Box<dyn Error + Send + Sync>>> + Send>>

The future response value.
Source§

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Source§

fn call(&mut self, task: Task<Args, Ctx, IdType>) -> Self::Future

Process the request and return the response asynchronously. Read more
Source§

impl<T, F, Args: Send + 'static, R, Ctx: Send + 'static, IdType: Send + Clone + 'static, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> Service<Task<Args, Ctx, IdType>> for TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)>
where T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) -> F + Send + Clone + 'static, F: Future + Send, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args, Ctx, IdType>> + Send, <A8 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args, Ctx, IdType>> + Send, <A9 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args, Ctx, IdType>> + Send, <A10 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A11: FromRequest<Task<Args, Ctx, IdType>> + Send, <A11 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A12: FromRequest<Task<Args, Ctx, IdType>> + Send, <A12 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A13: FromRequest<Task<Args, Ctx, IdType>> + Send, <A13 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A14: FromRequest<Task<Args, Ctx, IdType>> + Send, <A14 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync,

Source§

type Response = R

Responses given by the service.
Source§

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.
Source§

type Future = Pin<Box<dyn Future<Output = Result<R, Box<dyn Error + Send + Sync>>> + Send>>

The future response value.
Source§

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Source§

fn call(&mut self, task: Task<Args, Ctx, IdType>) -> Self::Future

Process the request and return the response asynchronously. Read more
Source§

impl<T, F, Args: Send + 'static, R, Ctx: Send + 'static, IdType: Send + Clone + 'static, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> Service<Task<Args, Ctx, IdType>> for TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)>
where T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) -> F + Send + Clone + 'static, F: Future + Send, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args, Ctx, IdType>> + Send, <A8 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args, Ctx, IdType>> + Send, <A9 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args, Ctx, IdType>> + Send, <A10 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A11: FromRequest<Task<Args, Ctx, IdType>> + Send, <A11 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A12: FromRequest<Task<Args, Ctx, IdType>> + Send, <A12 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A13: FromRequest<Task<Args, Ctx, IdType>> + Send, <A13 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A14: FromRequest<Task<Args, Ctx, IdType>> + Send, <A14 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A15: FromRequest<Task<Args, Ctx, IdType>> + Send, <A15 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync,

Source§

type Response = R

Responses given by the service.
Source§

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.
Source§

type Future = Pin<Box<dyn Future<Output = Result<R, Box<dyn Error + Send + Sync>>> + Send>>

The future response value.
Source§

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Source§

fn call(&mut self, task: Task<Args, Ctx, IdType>) -> Self::Future

Process the request and return the response asynchronously. Read more
Source§

impl<T, F, Args: Send + 'static, R, Ctx: Send + 'static, IdType: Send + Clone + 'static, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> Service<Task<Args, Ctx, IdType>> for TaskFn<T, Args, Ctx, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)>
where T: FnMut(Args, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) -> F + Send + Clone + 'static, F: Future + Send, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args, Ctx, IdType>> + Send, <A1 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args, Ctx, IdType>> + Send, <A2 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args, Ctx, IdType>> + Send, <A3 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args, Ctx, IdType>> + Send, <A4 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args, Ctx, IdType>> + Send, <A5 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args, Ctx, IdType>> + Send, <A6 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args, Ctx, IdType>> + Send, <A7 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args, Ctx, IdType>> + Send, <A8 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args, Ctx, IdType>> + Send, <A9 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args, Ctx, IdType>> + Send, <A10 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A11: FromRequest<Task<Args, Ctx, IdType>> + Send, <A11 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A12: FromRequest<Task<Args, Ctx, IdType>> + Send, <A12 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A13: FromRequest<Task<Args, Ctx, IdType>> + Send, <A13 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A14: FromRequest<Task<Args, Ctx, IdType>> + Send, <A14 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A15: FromRequest<Task<Args, Ctx, IdType>> + Send, <A15 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync, A16: FromRequest<Task<Args, Ctx, IdType>> + Send, <A16 as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync,

Source§

type Response = R

Responses given by the service.
Source§

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.
Source§

type Future = Pin<Box<dyn Future<Output = Result<R, Box<dyn Error + Send + Sync>>> + Send>>

The future response value.
Source§

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Source§

fn call(&mut self, task: Task<Args, Ctx, IdType>) -> Self::Future

Process the request and return the response asynchronously. Read more
Source§

impl<T, F, Args: Send + 'static, R, Ctx: Send + 'static, IdType: Send + Clone + 'static, A> Service<Task<Args, Ctx, IdType>> for TaskFn<T, Args, Ctx, A>
where T: FnMut(Args, A) -> F + Send + Clone + 'static, F: Future + Send, F::Output: IntoResponse<Output = R>, A: FromRequest<Task<Args, Ctx, IdType>> + Send, <A as FromRequest<Task<Args, Ctx, IdType>>>::Error: Error + 'static + Send + Sync,

Source§

type Response = R

Responses given by the service.
Source§

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.
Source§

type Future = Pin<Box<dyn Future<Output = Result<R, Box<dyn Error + Send + Sync>>> + Send>>

The future response value.
Source§

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Source§

fn call(&mut self, task: Task<Args, Ctx, IdType>) -> Self::Future

Process the request and return the response asynchronously. Read more
Source§

impl<T: Copy, Args, Ctx, FnArgs> Copy for TaskFn<T, Args, Ctx, FnArgs>

Auto Trait Implementations§

§

impl<F, Args, Ctx, FnArgs> Freeze for TaskFn<F, Args, Ctx, FnArgs>
where F: Freeze,

§

impl<F, Args, Ctx, FnArgs> RefUnwindSafe for TaskFn<F, Args, Ctx, FnArgs>
where F: RefUnwindSafe, FnArgs: RefUnwindSafe, Args: RefUnwindSafe, Ctx: RefUnwindSafe,

§

impl<F, Args, Ctx, FnArgs> Send for TaskFn<F, Args, Ctx, FnArgs>
where F: Send, FnArgs: Send, Args: Send, Ctx: Send,

§

impl<F, Args, Ctx, FnArgs> Sync for TaskFn<F, Args, Ctx, FnArgs>
where F: Sync, FnArgs: Sync, Args: Sync, Ctx: Sync,

§

impl<F, Args, Ctx, FnArgs> Unpin for TaskFn<F, Args, Ctx, FnArgs>
where F: Unpin, FnArgs: Unpin, Args: Unpin, Ctx: Unpin,

§

impl<F, Args, Ctx, FnArgs> UnwindSafe for TaskFn<F, Args, Ctx, FnArgs>
where F: UnwindSafe, FnArgs: UnwindSafe, Args: UnwindSafe, Ctx: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

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

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

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

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<Args, Ctx, S, B> IntoWorkerService<B, S, Args, Ctx> for S
where S: Service<Task<Args, Ctx, <B as Backend>::IdType>>, B: Backend<Args = Args, Context = Ctx>,

Source§

fn into_service(self, _: &B) -> S

Build the service from the backend
Source§

impl<T, Args, Ctx, Svc, B, M> IntoWorkerServiceExt<Args, Ctx, Svc, B, M> for T
where T: IntoWorkerService<B, Svc, Args, Ctx>, B: Backend<Args = Args, Context = Ctx>, Svc: Service<Task<Args, Ctx, <B as Backend>::IdType>>,

Source§

fn build_with( self, builder: WorkerBuilder<Args, Ctx, B, M>, ) -> Worker<Args, Ctx, B, Svc, M>

Consumes the builder and returns a worker
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.
Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more