Struct FetcherTask 

pub struct FetcherTask<OUT, T> { /* private fields */ }

Trait Implementations

impl<OUT, T> Agent for FetcherTask<OUT, T>

where OUT: Msg, T: Tag,

type Context = AgentSession<FetcherTask<OUT, T>>

Context is the functional environment in which an actor operates.

type Link = Address<FetcherTask<OUT, T>>

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<FetcherTask<OUT, T>>

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<OUT, T> DoAsync for FetcherTask<OUT, T>

where OUT: Msg, T: Tag,

fn once<'life0, 'life1, 'async_trait>( &'life0 mut self, _: &'life1 mut (), ) -> Pin<Box<dyn Future<Output = Result<Next<FetcherTask<OUT, T>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, FetcherTask<OUT, T>: '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 repeat<'life0, 'life1, 'async_trait>( &'life0 mut self, state: &'life1 mut S, ) -> Pin<Box<dyn Future<Output = Result<Option<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<OUT, T> IntoFuture for FetcherTask<OUT, T>

type Output = Result<OUT, FetchError>

The output that the future will produce on completion.

type IntoFuture = Fetcher<OUT>

Which kind of future are we turning this into?

fn into_future(self) -> <FetcherTask<OUT, T> as IntoFuture>::IntoFuture

Creates a future from a value.