Struct meio::handlers::InteractionTask

pub struct InteractionTask<I: Interaction> { /* fields omitted */ }

Interaction task that can be awaited or aattached to a Context.

Implementations

impl<I: Interaction> InteractionTask<I>

pub async fn recv(self) -> Result<I::Output, Error>

Receive a value

Trait Implementations

impl<I> LiteTask for InteractionTask<I> where
    I: Interaction, 

type Output = I::Output

The result of a finished task.

fn log_target(&self) -> &str

The log target for the LiteTask.

fn interruptable_routine<'async_trait>(
    self
) -> Pin<Box<dyn Future<Output = Result<Self::Output, Error>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Routine that can be unconditionally interrupted.

fn routine<'async_trait>(
    self,
    stop: StopReceiver
) -> Pin<Box<dyn Future<Output = Result<Self::Output, Error>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Routine of the task that can contain loops. It can taks into accout provided receiver to implement graceful interruption.

fn pre_repeatable_routine<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Called before repeatable_routine for initialization. The routine will be interrupted if this method failed.

fn repeatable_routine<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<Self::Output>, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Routine that will be repeated till fail or success.

fn routine_wait<'life0, 'async_trait>(
    &'life0 mut self,
    _last_attempt: Instant,
    _succeed: bool
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Check of the every intaration of a routine.

impl<T, I, M> TaskEliminated<InteractionTask<I>, M> for T where
    T: InteractionDone<I, M>,
    I: Interaction,
    M: Tag, 

fn handle<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    _id: IdOf<InteractionTask<I>>,
    tag: M,
    result: Result<I::Output, TaskError>,
    ctx: &'life1 mut Context<Self>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Called when the Task finished.