Struct Task 

pub struct Task<Args> {
    pub args: Args,
    /* private fields */
}

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

Fields

args: Args

The argument task part

Implementations

impl<Args> Task<Args>

pub fn new(args: Args) -> Self

Creates a new task given some args

Used to easily create a ready task. Please prefer to use TaskBuilder if you need to modify ExecutionContext

pub fn ctx(&self) -> &Arc<ExecutionContext>

Returns the execution context associated with the task.

impl<Args> Task<Args>

pub fn take(self) -> (Args, Arc<ExecutionContext>)

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 map_args<F, NewArgs>(self, f: F) -> Task<NewArgs>

where F: FnOnce(Args) -> NewArgs,

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

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

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

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

pub fn map_context<F>(self, f: F) -> Self

where F: FnOnce(Arc<ExecutionContext>) -> Arc<ExecutionContext>,

Maps the execution_context using the provided function, consuming the task

pub fn into_builder(self) -> TaskBuilder<Args>

Converts the task into a TaskBuilder

pub fn inject_data<D>(&mut self, data: D) -> Option<D>

where D: Send + Clone + Sync + 'static,

Inject data into the execution context via Arc::make_mut

If an extension of this type already existed, it will be returned.

pub fn inject_metadata<M>(&mut self, value: &M) -> Result<(), M::Error>

where M: Metadata,

Inject metadata into the execution context via Arc::make_mut

Methods from Deref<Target = ExecutionContext>

pub fn task_id(&self) -> Option<&TaskId>

Returns the task’s ID, if one has been allocated.

pub fn data(&self) -> &Extensions

Returns the extensions associated with the task.

pub fn attempt(&self) -> usize

Returns the number of attempts made to execute the task.

pub fn raw_attempt(&self) -> &Attempt

Get the atomic attempt

pub fn status(&self) -> Status

Returns the current status of the task.

pub fn raw_status(&self) -> &AtomicStatus

Get the atomic status

pub fn run_at(&self) -> Option<u64>

Returns the time at which the task is scheduled to run.

Returns None if no run time has been specified.

pub fn done_at(&self) -> Option<u64>

Returns the time at which the task was completed.

Returns None if the task has not been completed.

pub fn lock_at(&self) -> Option<u64>

Returns the time at which the task was locked.

Returns None if the task is not locked.

pub fn lock_by(&self) -> Option<&str>

Returns the identifier of the worker or process currently holding the lock on this task.

Returns None if the task is not currently locked.

pub fn idempotency_key(&self) -> Option<&str>

Returns the idempotency key associated with the task.

Returns None if no idempotency key has been specified.

pub fn metadata(&self) -> &MetadataStore

Returns the metadata associated with the task.

pub fn max_attempts(&self) -> Option<usize>

Returns the maximum number of attempts allowed for the task.

Returns None if no maximum has been specified.

pub fn priority(&self) -> Option<usize>

Returns the priority of the task.

Returns None if no priority has been specified.

pub fn queue(&self) -> Option<&Queue>

Returns the queue to which the task belongs.

Returns None if the task is not associated with a queue.

pub fn runs(&self) -> &[Run]

Returns the runs recorded for this task.

Trait Implementations

impl<Args: Clone> Clone for Task<Args>

fn clone(&self) -> Task<Args>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Args: Debug> Debug for Task<Args>

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

Formats the value using the given formatter.

impl<Args: Default> Default for Task<Args>

fn default() -> Task<Args>

Returns the “default value” for a type.

impl<Args> Deref for Task<Args>

type Target = ExecutionContext

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<A: Send + 'static> From<A> for Task<A>

fn from(value: A) -> Self

Converts to this type from the input type.

impl<Args> FromRequest<Task<Args>> for Queue

where Args: Sync,

type Error = QueueError

The error type that can occur during extraction.

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

Perform the extraction.

impl<Args> FromRequest<Task<Args>> for Attempt

where Args: Sync,

type Error = !

The error type that can occur during extraction.

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

Perform the extraction.

impl<Args: Sync> FromRequest<Task<Args>> for TaskContext

type Error = MissingDataError

The error type that can occur during extraction.

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

Perform the extraction.

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

type Error = MissingDataError

The error type that can occur during extraction.

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

Perform the extraction.

impl<T: Metadata, Args: Send + Sync> FromRequest<Task<Args>> for Meta<T>

type Error = <T as Metadata>::Error

The error type that can occur during extraction.

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

Perform the extraction.

impl<Args: Send + Sync> FromRequest<Task<Args>> for MetadataStore

type Error = !

The error type that can occur during extraction.

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

Perform the extraction.

impl<Args: Sync> FromRequest<Task<Args>> for TaskId

type Error = MissingDataError

The error type that can occur during extraction.

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

Perform the extraction.

impl<Args: Sync> FromRequest<Task<Args>> for WorkerContext

type Error = MissingDataError

The error type that can occur during extraction.

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

Perform the extraction.

impl<Args: Sync, Res> FromRequest<Task<Args>> for TaskRunner<Res>

type Error = MissingDataError

The error type that can occur during extraction.

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

Perform the extraction.

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

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

type Response = <S as Service<Task<Args>>>::Response

Responses given by the service.

type Error = <S as Service<Task<Args>>>::Error

Errors produced by the service.

type Future = <S as Service<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Args, R> Service<Task<Args>> for TaskFn<T, Args, ()>

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>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Args: Send + 'static, R, A> Service<Task<Args>> for TaskFn<T, Args, A>

where T: FnMut(Args, A) -> F + Send + Clone + 'static, F: Future + Send, F::Output: IntoResponse<Output = R>, A: FromRequest<Task<Args>> + Send, <A as FromRequest<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Args: Send + 'static, R, A1, A2> Service<Task<Args>> for TaskFn<T, Args, (A1, A2)>

where T: FnMut(Args, A1, A2) -> F + Send + Clone + 'static, F: Future + Send, F::Output: IntoResponse<Output = R>, A1: FromRequest<Task<Args>> + Send, <A1 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args>> + Send, <A2 as FromRequest<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Args: Send + 'static, R, A1, A2, A3> Service<Task<Args>> for TaskFn<T, Args, (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>> + Send, <A1 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args>> + Send, <A2 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args>> + Send, <A3 as FromRequest<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Args: Send + 'static, R, A1, A2, A3, A4> Service<Task<Args>> for TaskFn<T, Args, (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>> + Send, <A1 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args>> + Send, <A2 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args>> + Send, <A3 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args>> + Send, <A4 as FromRequest<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Args: Send + 'static, R, A1, A2, A3, A4, A5> Service<Task<Args>> for TaskFn<T, Args, (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>> + Send, <A1 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args>> + Send, <A2 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args>> + Send, <A3 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args>> + Send, <A4 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args>> + Send, <A5 as FromRequest<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Args: Send + 'static, R, A1, A2, A3, A4, A5, A6> Service<Task<Args>> for TaskFn<T, Args, (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>> + Send, <A1 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args>> + Send, <A2 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args>> + Send, <A3 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args>> + Send, <A4 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args>> + Send, <A5 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args>> + Send, <A6 as FromRequest<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Args: Send + 'static, R, A1, A2, A3, A4, A5, A6, A7> Service<Task<Args>> for TaskFn<T, Args, (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>> + Send, <A1 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args>> + Send, <A2 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args>> + Send, <A3 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args>> + Send, <A4 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args>> + Send, <A5 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args>> + Send, <A6 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args>> + Send, <A7 as FromRequest<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Args: Send + 'static, R, A1, A2, A3, A4, A5, A6, A7, A8> Service<Task<Args>> for TaskFn<T, Args, (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>> + Send, <A1 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args>> + Send, <A2 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args>> + Send, <A3 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args>> + Send, <A4 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args>> + Send, <A5 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args>> + Send, <A6 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args>> + Send, <A7 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args>> + Send, <A8 as FromRequest<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Args: Send + 'static, R, A1, A2, A3, A4, A5, A6, A7, A8, A9> Service<Task<Args>> for TaskFn<T, Args, (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>> + Send, <A1 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args>> + Send, <A2 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args>> + Send, <A3 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args>> + Send, <A4 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args>> + Send, <A5 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args>> + Send, <A6 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args>> + Send, <A7 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args>> + Send, <A8 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args>> + Send, <A9 as FromRequest<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Args: Send + 'static, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> Service<Task<Args>> for TaskFn<T, Args, (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>> + Send, <A1 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args>> + Send, <A2 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args>> + Send, <A3 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args>> + Send, <A4 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args>> + Send, <A5 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args>> + Send, <A6 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args>> + Send, <A7 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args>> + Send, <A8 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args>> + Send, <A9 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args>> + Send, <A10 as FromRequest<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Args: Send + 'static, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> Service<Task<Args>> for TaskFn<T, Args, (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>> + Send, <A1 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args>> + Send, <A2 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args>> + Send, <A3 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args>> + Send, <A4 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args>> + Send, <A5 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args>> + Send, <A6 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args>> + Send, <A7 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args>> + Send, <A8 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args>> + Send, <A9 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args>> + Send, <A10 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A11: FromRequest<Task<Args>> + Send, <A11 as FromRequest<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Args: Send + 'static, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> Service<Task<Args>> for TaskFn<T, Args, (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>> + Send, <A1 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args>> + Send, <A2 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args>> + Send, <A3 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args>> + Send, <A4 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args>> + Send, <A5 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args>> + Send, <A6 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args>> + Send, <A7 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args>> + Send, <A8 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args>> + Send, <A9 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args>> + Send, <A10 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A11: FromRequest<Task<Args>> + Send, <A11 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A12: FromRequest<Task<Args>> + Send, <A12 as FromRequest<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Args: Send + 'static, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> Service<Task<Args>> for TaskFn<T, Args, (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>> + Send, <A1 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args>> + Send, <A2 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args>> + Send, <A3 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args>> + Send, <A4 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args>> + Send, <A5 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args>> + Send, <A6 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args>> + Send, <A7 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args>> + Send, <A8 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args>> + Send, <A9 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args>> + Send, <A10 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A11: FromRequest<Task<Args>> + Send, <A11 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A12: FromRequest<Task<Args>> + Send, <A12 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A13: FromRequest<Task<Args>> + Send, <A13 as FromRequest<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Args: Send + 'static, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> Service<Task<Args>> for TaskFn<T, Args, (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>> + Send, <A1 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args>> + Send, <A2 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args>> + Send, <A3 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args>> + Send, <A4 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args>> + Send, <A5 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args>> + Send, <A6 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args>> + Send, <A7 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args>> + Send, <A8 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args>> + Send, <A9 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args>> + Send, <A10 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A11: FromRequest<Task<Args>> + Send, <A11 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A12: FromRequest<Task<Args>> + Send, <A12 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A13: FromRequest<Task<Args>> + Send, <A13 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A14: FromRequest<Task<Args>> + Send, <A14 as FromRequest<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Args: Send + 'static, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> Service<Task<Args>> for TaskFn<T, Args, (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>> + Send, <A1 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args>> + Send, <A2 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args>> + Send, <A3 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args>> + Send, <A4 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args>> + Send, <A5 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args>> + Send, <A6 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args>> + Send, <A7 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args>> + Send, <A8 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args>> + Send, <A9 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args>> + Send, <A10 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A11: FromRequest<Task<Args>> + Send, <A11 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A12: FromRequest<Task<Args>> + Send, <A12 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A13: FromRequest<Task<Args>> + Send, <A13 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A14: FromRequest<Task<Args>> + Send, <A14 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A15: FromRequest<Task<Args>> + Send, <A15 as FromRequest<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Args: Send + 'static, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> Service<Task<Args>> for TaskFn<T, Args, (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>> + Send, <A1 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A2: FromRequest<Task<Args>> + Send, <A2 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A3: FromRequest<Task<Args>> + Send, <A3 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A4: FromRequest<Task<Args>> + Send, <A4 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A5: FromRequest<Task<Args>> + Send, <A5 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A6: FromRequest<Task<Args>> + Send, <A6 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A7: FromRequest<Task<Args>> + Send, <A7 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A8: FromRequest<Task<Args>> + Send, <A8 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A9: FromRequest<Task<Args>> + Send, <A9 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A10: FromRequest<Task<Args>> + Send, <A10 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A11: FromRequest<Task<Args>> + Send, <A11 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A12: FromRequest<Task<Args>> + Send, <A12 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A13: FromRequest<Task<Args>> + Send, <A13 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A14: FromRequest<Task<Args>> + Send, <A14 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A15: FromRequest<Task<Args>> + Send, <A15 as FromRequest<Task<Args>>>::Error: Error + 'static + Send + Sync, A16: FromRequest<Task<Args>> + Send, <A16 as FromRequest<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

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

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

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>) -> Self::Future

Process the request and return the response asynchronously.

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

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

type Response = <S as Service<Task<Args>>>::Response

Responses given by the service.

type Error = <S as Service<Task<Args>>>::Error

Errors produced by the service.

type Future = <S as Service<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

impl<S, Args, Fut, T, Executor, ExecErr> Service<Task<Args>> for ParallelizeService<S, Executor>

where S: Service<Task<Args>, Future = Fut>, Executor: Fn(Fut) -> T + Send + 'static, Fut: Future<Output = Result<S::Response, S::Error>> + Send + 'static, T: Future<Output = Result<Result<S::Response, S::Error>, ExecErr>> + Send + 'static, S::Error: Into<BoxDynError> + Send + 'static, ExecErr: Into<BoxDynError>, S::Response: Send + 'static,

type Response = <S as Service<Task<Args>>>::Response

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<<ParallelizeService<S, Executor> as Service<Task<Args>>>::Response, <ParallelizeService<S, Executor> as Service<Task<Args>>>::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, request: Task<Args>) -> Self::Future

Process the request and return the response asynchronously.

impl<S, Args> Service<Task<Args>> for LifecycleService<S>

where S: Service<Task<Args>>, S::Error: Into<BoxDynError>,

type Response = <S as Service<Task<Args>>>::Response

Responses given by the service.

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

Errors produced by the service.

type Future = LifecycleFuture<<S as Service<Task<Args>>>::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>) -> Self::Future

Process the request and return the response asynchronously.

impl<B, Err> Sink<Task<<B as WireFormatBackend>::Compact>> for Shared<B>

where B: Backend<Error = Err> + Sink<Task<B::Compact>, Error = Err> + Unpin + WireFormatBackend, B::Codec: Unpin, B::Compact: Unpin,

type Error = Err

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

fn start_send( self: Pin<&mut Self>, item: Task<B::Compact>, ) -> 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_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

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<P> Sink<Task<<P as Persistence>::Compact>> for Persisted<P>

where P: Persistence + Unpin, P::Compact: Send + Unpin + 'static,

Available on crate feature sleep only.

type Error = <P as Persistence>::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<P::Compact>, ) -> 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, DB, Fetch, S, Config> Sink<Task<Args>> for CustomBackend<Args, DB, Fetch, S, Config>

where S: Sink<Task<Args>>, S::Error: Into<BoxDynError>,

type Error = CustomBackendError

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>) -> 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> Sink<Task<Args>> for MemoryStorage<Args>

type Error = MemoryStorageError

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>) -> 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> Sink<Task<Args>> for MemorySink<Args>

type Error = MemoryStorageError

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>) -> 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<T> Sink<Task<T>> for VecDequeBackend<T>

where T: Send + Unpin + 'static,

type Error = VecDequeError

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<T>) -> 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.