Struct RunTask 

pub struct RunTask<TTransformed, F, N> {
    pub function: F,
    pub next_step: N,
    pub message_carried_over: Option<Message<TTransformed>>,
    pub commit_request_carried_over: Option<CommitRequest>,
}

Fields

function: F

next_step: N

message_carried_over: Option<Message<TTransformed>>

commit_request_carried_over: Option<CommitRequest>

Implementations

impl<TTransformed, F, N> RunTask<TTransformed, F, N>

pub fn new(function: F, next_step: N) -> Self

Trait Implementations

impl<TPayload, TTransformed, F, N> ProcessingStrategy<TPayload> for RunTask<TTransformed, F, N>

where TTransformed: Send + Sync, F: FnMut(Message<TPayload>) -> Result<Message<TTransformed>, SubmitError<TPayload>> + Send + Sync + 'static, N: ProcessingStrategy<TTransformed> + 'static,

fn poll(&mut self) -> Result<Option<CommitRequest>, StrategyError>

Poll the processor to check on the status of asynchronous tasks or perform other scheduled work.

fn submit( &mut self, message: Message<TPayload>, ) -> Result<(), SubmitError<TPayload>>

Submit a message for processing.

fn terminate(&mut self)

Close the processing strategy immediately, abandoning any work in progress. No more messages should be accepted by the instance after this method has been called.

fn join( &mut self, timeout: Option<Duration>, ) -> Result<Option<CommitRequest>, StrategyError>

Block until the processing strategy has completed all previously submitted work, or the provided timeout has been reached. This method should be called after close to provide a graceful shutdown.