Enum Routine 

pub enum Routine {
    AsyncRoutine(Box<dyn AsyncRoutine>),
    SyncRoutine(Box<dyn SyncRoutine>),
    Detached,
}

Variants

AsyncRoutine(Box<dyn AsyncRoutine>)

SyncRoutine(Box<dyn SyncRoutine>)

Detached

Implementations

impl Routine

pub fn new_async<R: AsyncRoutine>(routine: R) -> Self

impl Routine

pub fn new_sync<R: SyncRoutine>(routine: R) -> Self

Trait Implementations

impl Agent for Routine

type Context = AgentSession<Routine>

Context is the functional environment in which an actor operates.

type Link = Address<Routine>

Link is a means of interacting with an actor—it essentially defines the available methods that send specific types of messages.

fn begin(&mut self) -> Next<Self>

The begin method is an initialization method without context.

fn initialize(&mut self, _ctx: &mut Context<Self>) -> Next<Self>

The initialize method is called first when the actor starts. It should return a Next state, which the actor will transition to.

fn interrupt(&mut self, ctx: &mut Context<Self>)

The method is called when an attempt is made to interrupt the agent’s execution.

fn event<'life0, 'life1, 'async_trait>( &'life0 mut self, 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,

The method responsible for handling messages in actor mode.

fn failed(&mut self, err: Error, _ctx: &mut Context<Self>)

This method is called every time a handler call ends with an unhandled error.

fn rollback<'life0, 'life1, 'async_trait>( _this: Option<&'life0 mut Self>, _err: Error, _ctx: &'life1 mut Context<Self>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

The rollback method is called when the agent is completely terminated due to an error. In this case, the method receives a reference to the agent instance, if it was successfully preserved, as well as the error that caused the agent’s runtime to fail fatally. Additionally, a context is available to extract additional data.

fn finalize(&mut self, _ctx: &mut Context<Self>)

The finalize method is called when the agent has fully terminated. This method has access to the context. By default, its implementation calls another agent method, end.

fn end(&mut self)

The end method is called when the agent’s runtime has fully terminated to perform final actions with the agent.

impl DoAsync<Box<dyn AsyncRoutine>> for Routine

fn repeat<'life0, 'life1, 'async_trait>( &'life0 mut self, boxed: &'life1 mut Box<dyn AsyncRoutine>, ) -> Pin<Box<dyn Future<Output = Result<Option<Next<Self>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, state: S, ctx: &'life1 mut Context<Self>, ) -> Pin<Box<dyn Future<Output = Result<Next<Self>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Send + 'async_trait,

fn once<'life0, 'life1, 'async_trait>( &'life0 mut self, _state: &'life1 mut S, ) -> Pin<Box<dyn Future<Output = Result<Next<Self>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Send + 'async_trait,

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

where 'life0: 'async_trait, Self: Send + 'async_trait,

fn fallback_with_context<'life0, 'life1, 'async_trait>( &'life0 mut self, err: Error, _ctx: &'life1 mut Context<Self>, ) -> Pin<Box<dyn Future<Output = Next<Self>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Send + 'async_trait,

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

where 'life0: 'async_trait, Self: Send + 'async_trait,

impl DoSync<Box<dyn SyncRoutine>> for Routine

fn repeat( &mut self, boxed: &mut Box<dyn SyncRoutine>, ) -> Result<Option<Next<Self>>>

fn perform(&mut self, state: S, stopper: Stopper) -> Result<Next<Self>, Error>

fn once(&mut self, _state: &mut S) -> Result<Next<Self>, Error>

fn repair(&mut self, err: Error) -> Result<(), Error>

fn fallback(&mut self, err: Error) -> Next<Self>