Struct Task 

pub struct Task<Args, Context, IdType = RandomId> {
    pub args: Args,
    pub parts: Parts<Context, IdType>,
}

Represents a task which will be executed Should be considered a single unit of work

Fields

args: Args

The argument task part

parts: Parts<Context, IdType>

Parts of the task eg id, attempts and context

Implementations

impl<Args, Ctx: Default, IdType> Task<Args, Ctx, IdType>

pub fn builder(args: Args) -> TaskBuilder<Args, Ctx, IdType>

Create a TaskBuilder with the given args

impl<Args, Ctx, IdType> Task<Args, Ctx, IdType>

pub fn new(args: Args) -> Self

where Ctx: Default,

Creates a new Task

pub fn new_with_ctx(req: Args, ctx: Ctx) -> Self

Creates a task with context provided

pub fn new_with_data(req: Args, data: Extensions, ctx: Ctx) -> Self

Creates a task with data and context provided

pub fn take(self) -> (Args, Parts<Ctx, IdType>)

Take the task into its parts

pub async fn extract<T: FromRequest<Self>>(&self) -> Result<T, T::Error>

Extract a value of type T from the task’s context

Uses FromRequest trait to extract the value.

pub fn into_builder(self) -> TaskBuilder<Args, Ctx, IdType>

Converts the task into a builder pattern.

impl<Args, Ctx, IdType> Task<Args, Ctx, IdType>

pub fn try_map<F, NewArgs, Err>( self, f: F, ) -> Result<Task<NewArgs, Ctx, IdType>, Err>

where F: FnOnce(Args) -> Result<NewArgs, Err>,

Maps the args field using the provided function, consuming the task.

pub fn map<F, NewArgs>(self, f: F) -> Task<NewArgs, Ctx, IdType>

where F: FnOnce(Args) -> NewArgs,

Maps the args field using the provided function, consuming the task.

pub fn map_all<F, NewArgs, NewCtx>(self, f: F) -> Task<NewArgs, NewCtx, IdType>

where F: FnOnce(Args, Parts<Ctx, IdType>) -> (NewArgs, Parts<NewCtx, IdType>),

Maps both args and parts together.

pub fn map_parts<F, NewCtx>(self, f: F) -> Task<Args, NewCtx, IdType>

where F: FnOnce(Parts<Ctx, IdType>) -> Parts<NewCtx, IdType>,

Maps only the parts field.

Trait Implementations

impl<Args: Clone, Context: Clone, IdType: Clone> Clone for Task<Args, Context, IdType>

fn clone(&self) -> Task<Args, Context, IdType>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Args: Debug, Context: Debug, IdType: Debug> Debug for Task<Args, Context, IdType>

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

Formats the value using the given formatter.

impl<Args: Default, Context: Default, IdType: Default> Default for Task<Args, Context, IdType>

fn default() -> Task<Args, Context, IdType>

Returns the “default value” for a type.

impl<'de, Args, Context, IdType> Deserialize<'de> for Task<Args, Context, IdType>

where Args: Deserialize<'de>, Context: Deserialize<'de>, IdType: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Args: Sync, Ctx: Sync, IdType: Sync + Send> FromRequest<Task<Args, Ctx, IdType>> for Attempt

type Error = Infallible

The error type that can occur during extraction.

async fn from_request( task: &Task<Args, Ctx, IdType>, ) -> Result<Self, Self::Error>

Perform the extraction.

impl<T: Clone + Send + Sync + 'static, Args: Sync, Ctx: Sync, IdType: Sync + Send> FromRequest<Task<Args, Ctx, IdType>> for Data<T>

type Error = MissingDataError

The error type that can occur during extraction.

async fn from_request( task: &Task<Args, Ctx, IdType>, ) -> Result<Self, Self::Error>

Perform the extraction.

impl<Args: Sync, Ctx: Sync + Clone, IdType: Sync + Send> FromRequest<Task<Args, Ctx, IdType>> for LongRunnerCtx

type Error = MissingDataError

The error type that can occur during extraction.

async fn from_request( task: &Task<Args, Ctx, IdType>, ) -> Result<Self, Self::Error>

Perform the extraction.

impl<T, Args: Send + Sync, Ctx: MetadataExt<T> + Send + Sync, IdType: Send + Sync> FromRequest<Task<Args, Ctx, IdType>> for Meta<T>

type Error = <Ctx as MetadataExt<T>>::Error

The error type that can occur during extraction.

async fn from_request( task: &Task<Args, Ctx, IdType>, ) -> Result<Self, Self::Error>

Perform the extraction.

impl<Args: Sync, Ctx: Sync, IdType: Sync + Send + Clone> FromRequest<Task<Args, Ctx, IdType>> for TaskId<IdType>

type Error = MissingDataError

The error type that can occur during extraction.

async fn from_request( task: &Task<Args, Ctx, IdType>, ) -> Result<Self, Self::Error>

Perform the extraction.

impl<Args: Sync, Ctx: Sync, IdType: Sync + Send> FromRequest<Task<Args, Ctx, IdType>> for WorkerContext

type Error = MissingDataError

The error type that can occur during extraction.

async fn from_request( task: &Task<Args, Ctx, IdType>, ) -> Result<Self, Self::Error>

Perform the extraction.

impl<Args, Context, IdType> Serialize for Task<Args, Context, IdType>

where Args: Serialize, Context: Serialize, IdType: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S, A, Args, Ctx, Res, IdType> Service<Task<Args, Ctx, IdType>> for AcknowledgeService<S, A>

where S: Service<Task<Args, Ctx, IdType>, Response = Res>, A: Acknowledge<Res, Ctx, IdType> + Clone + Send + 'static, S::Error: Into<BoxDynError>, A::Error: Error + Send + Sync + 'static, S::Future: Send + 'static, A::Future: Send + 'static, Ctx: Clone + Sync + 'static + Send, Res: Send, IdType: Send + Clone + 'static,

type Response = Res

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

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

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

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

Process the request and return the response asynchronously.

impl<S, T, Args, Ctx, IdType> Service<Task<Args, Ctx, IdType>> for AddExtension<S, T>

where S: Service<Task<Args, Ctx, IdType>>, T: Clone + Send + Sync + 'static,

type Response = <S as Service<Task<Args, Ctx, IdType>>>::Response

Responses given by the service.

type Error = <S as Service<Task<Args, Ctx, IdType>>>::Error

Errors produced by the service.

type Future = <S as Service<Task<Args, Ctx, IdType>>>::Future

The future response value.

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

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

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

Process the request and return the response asynchronously.

impl<S, Args, Ctx, IdType> Service<Task<Args, Ctx, IdType>> for EventListenerService<S>

where S: Service<Task<Args, Ctx, IdType>>,

type Response = <S as Service<Task<Args, Ctx, IdType>>>::Response

Responses given by the service.

type Error = <S as Service<Task<Args, Ctx, IdType>>>::Error

Errors produced by the service.

type Future = <S as Service<Task<Args, Ctx, IdType>>>::Future

The future response value.

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

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

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

Process the request and return the response asynchronously.

impl<S, Args, Ctx, IdType> Service<Task<Args, Ctx, IdType>> for LongRunningService<S>

where S: Service<Task<Args, Ctx, IdType>>, S::Future: Send + 'static, S::Response: Send, S::Error: Send,

type Response = <S as Service<Task<Args, Ctx, IdType>>>::Response

Responses given by the service.

type Error = <S as Service<Task<Args, Ctx, IdType>>>::Error

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<S as Service<Task<Args, Ctx, IdType>>>::Response, <S as Service<Task<Args, Ctx, IdType>>>::Error>> + Send>>

The future response value.

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

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

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

Process the request and return the response asynchronously.

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

type Response = R

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

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

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

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

Process the request and return the response asynchronously.

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,

type Response = R

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

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

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

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

Process the request and return the response asynchronously.

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,

type Response = R

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

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

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

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

Process the request and return the response asynchronously.

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,

type Response = R

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

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

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

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

Process the request and return the response asynchronously.

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,

type Response = R

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

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

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

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

Process the request and return the response asynchronously.

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,

type Response = R

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

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

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

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

Process the request and return the response asynchronously.

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,

type Response = R

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

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

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

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

Process the request and return the response asynchronously.

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,

type Response = R

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

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

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

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

Process the request and return the response asynchronously.

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,

type Response = R

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

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

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

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

Process the request and return the response asynchronously.

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,

type Response = R

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

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

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

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

Process the request and return the response asynchronously.

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,

type Response = R

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

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

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

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

Process the request and return the response asynchronously.

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,

type Response = R

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

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

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

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

Process the request and return the response asynchronously.

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,

type Response = R

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

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

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

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

Process the request and return the response asynchronously.

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,

type Response = R

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

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

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

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

Process the request and return the response asynchronously.

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,

type Response = R

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

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

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

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

Process the request and return the response asynchronously.

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,

type Response = R

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

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

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

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

Process the request and return the response asynchronously.

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,

type Response = R

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

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

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

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

Process the request and return the response asynchronously.

impl<S, Args, Ctx, Res, IdType> Service<Task<Args, Ctx, IdType>> for TestEmitService<S, Res, IdType>

where S: Service<Task<Args, Ctx, IdType>, Response = Res> + Send + 'static, S::Future: Send + 'static, Args: Send + 'static, Ctx: Send + 'static, S::Response: Send + 'static, S::Error: Into<BoxDynError> + Send, IdType: Send + 'static + Clone,

type Response = ()

Responses given by the service.

type Error = String

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<TestEmitService<S, Res, IdType> as Service<Task<Args, Ctx, IdType>>>::Response, <TestEmitService<S, Res, IdType> as Service<Task<Args, Ctx, IdType>>>::Error>> + Send>>

The future response value.

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

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

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

Process the request and return the response asynchronously.

impl<S, Args, Ctx, IdType> Service<Task<Args, Ctx, IdType>> for TrackerService<S>

where S: Service<Task<Args, Ctx, IdType>>,

type Response = <S as Service<Task<Args, Ctx, IdType>>>::Response

Responses given by the service.

type Error = <S as Service<Task<Args, Ctx, IdType>>>::Error

Errors produced by the service.

type Future = Tracked<AttemptOnPollFuture<<S as Service<Task<Args, Ctx, IdType>>>::Future>>

The future response value.

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

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

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

Process the request and return the response asynchronously.

impl<Args, Ctx> Sink<Task<Args, Ctx>> for MemorySink<Args, Ctx>

type Error = SendError

The type of value produced by the sink when an error occurs.

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

Attempts to prepare the Sink to receive a value.

fn start_send( self: Pin<&mut Self>, item: Task<Args, Ctx>, ) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

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

Flush any remaining output from this sink.

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

Flush any remaining output and close this sink, if necessary.

impl<Args, Ctx> Sink<Task<Args, Ctx>> for MemoryStorage<Args, Ctx>

type Error = SendError

The type of value produced by the sink when an error occurs.

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

Attempts to prepare the Sink to receive a value.

fn start_send( self: Pin<&mut Self>, item: Task<Args, Ctx>, ) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

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

Flush any remaining output from this sink.

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

Flush any remaining output and close this sink, if necessary.

impl<Args, Ctx, IdType, DB, Fetch, S, Codec, Config> Sink<Task<Args, Ctx, IdType>> for CustomBackend<Args, DB, Fetch, S, IdType, Codec, Config>

where S: Sink<Task<Args, Ctx, IdType>>,

type Error = <S as Sink<Task<Args, Ctx, IdType>>>::Error

The type of value produced by the sink when an error occurs.

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

Attempts to prepare the Sink to receive a value.

fn start_send( self: Pin<&mut Self>, item: Task<Args, Ctx, IdType>, ) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

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

Flush any remaining output from this sink.

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

Flush any remaining output and close this sink, if necessary.

impl<Args: Unpin + Serialize> Sink<Task<Args, Map<String, Value>>> for JsonStorage<Args>

type Error = SendError

The type of value produced by the sink when an error occurs.

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

Attempts to prepare the Sink to receive a value.

fn start_send( self: Pin<&mut Self>, item: Task<Args, Map<String, Value>>, ) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

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

Flush any remaining output from this sink.

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

Flush any remaining output and close this sink, if necessary.