Struct Action 

pub struct Action<H: Handler> { /* private fields */ }

An Action<H> can be handled by a Handler using Action::handle_with. Actions can be created with the action! macro. Any Handler automatically implements HandleMessage<Action<H>>. Any Action<H> implements Protocol and Message automatically.

(See handler for an overview)

Implementations

impl<H: Handler> Action<H>

pub fn from_boxed_fn<F>(function: F) -> Self

where F: for<'a> FnOnce(&'a mut H, &'a mut H::State) -> BoxFuture<'a, Result<Flow<H>, H::Exception>> + Send + 'static,

Construct an action from a boxed FnOnce.

Normally an action is created with the action! macro.

pub async fn handle_with( self, handler: &mut H, state: &mut H::State, ) -> Result<Flow<H>, H::Exception>

where H: Handler,

Handle the Action<H> with Handler H.

Trait Implementations

impl<H> Debug for Action<H>

where H: Handler,

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

Formats the value using the given formatter.

impl<H: Handler> FromPayload<Action<H>> for Action<H>

fn from_payload(payload: Self) -> Self

where Self: Sized,

Create the Protocol from the Message::Payload.

fn try_into_payload(self) -> Result<Self, Self>

where Self: Sized,

Attempt to convert the protocol into the Message::Payload of M.

impl<H: Handler> HandleMessage<Action<H>> for H

fn handle_msg<'life0, 'life1, 'async_trait>( &'life0 mut self, state: &'life1 mut Self::State, action: Action<H>, ) -> Pin<Box<dyn Future<Output = Result<Flow<H>, H::Exception>> + Send + 'async_trait>>

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

impl<H: Handler> HandledBy<H> for Action<H>

fn handle_with<'life0, 'life1, 'async_trait>( self, handler: &'life0 mut H, state: &'life1 mut <H as Handler>::State, ) -> Pin<Box<dyn Future<Output = HandlerResult<H>> + Send + 'async_trait>>

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

impl<H: Handler> Message for Action<H>

type Returned = <() as MessageDerive<Action<H>>>::Returned

The value that is returned when the message is sent.

type Payload = <() as MessageDerive<Action<H>>>::Payload

The payload of the message that is sent to the actor.

fn create(self) -> (Self::Payload, Self::Returned)

This is called before the message is sent.

fn cancel(payload: Self::Payload, returned: Self::Returned) -> Self

This is called if the message cannot be sent.

impl<H: Handler> Protocol for Action<H>

fn into_boxed_payload(self) -> BoxPayload

Take out the payload as a BoxPayload.

fn try_from_boxed_payload(payload: BoxPayload) -> Result<Self, BoxPayload>

where Self: Sized,

Attempt to create the Protocol from a message.

fn accepts_msg(msg_id: &TypeId) -> bool

where Self: Sized,

Whether the Protocol accepts the type-id of a Message.