Trait Handler

pub trait Handler<M>: Actor {
    // Required method
    fn handle<'life0, 'life1, 'async_trait>(
        &'life0 mut self,
        cx: &'life1 Context<'_, Self>,
        message: M,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
}

A Handler allows an actor to handle a specific message type.

Required Methods

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, message: M, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Handle the next M-typed message.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Handler<CommActorMode> for CommActor

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, _cx: &'life1 Context<'_, CommActor>, mode: CommActorMode, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, CommActor: 'async_trait,

impl Handler<TestMessage> for TestActor

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, TestActor>, msg: TestMessage, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, TestActor: 'async_trait,

impl Handler<LogClientMessage> for LogClientActor

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, LogClientActor>, message: LogClientMessage, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, LogClientActor: 'async_trait,

impl Handler<LogForwardMessage> for LogForwardActor

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, LogForwardActor>, message: LogForwardMessage, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, LogForwardActor: 'async_trait,

impl Handler<LogMessage> for LogClientActor

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, LogClientActor>, message: LogMessage, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, LogClientActor: 'async_trait,

impl Handler<ActorSupervisionEvent> for MeshAgent

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, MeshAgent>, event: ActorSupervisionEvent, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MeshAgent: 'async_trait,

impl Handler<Wait> for TestActor

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, _: &'life1 Context<'_, TestActor>, __arg2: Wait, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, TestActor: 'async_trait,

impl Handler<CastMessage> for CommActor

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, CommActor>, cast_message: CastMessage, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, CommActor: 'async_trait,

impl Handler<EmptyMessage> for EmptyActor

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, _: &'life1 Context<'_, EmptyActor>, __arg2: EmptyMessage, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, EmptyActor: 'async_trait,

impl Handler<ForwardMessage> for CommActor

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, CommActor>, fwd_message: ForwardMessage, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, CommActor: 'async_trait,

impl Handler<MeshAgentMessage> for MeshAgent

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, MeshAgent>, message: MeshAgentMessage, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MeshAgent: 'async_trait,

Implementors

impl Handler<MailboxAdminMessage> for ProcActor

impl Handler<ProcMessage> for ProcActor

impl Handler<ProcSupervisionMessage> for SystemActor

impl Handler<WorldSupervisionMessage> for SystemActor

impl Handler<SystemMessage> for SystemActor

impl Handler<ActorSupervisionEvent> for ProcSupervisionCoordinator

impl Handler<ActorSupervisionEvent> for ProcActor

impl Handler<PingPongMessage> for PingPongActor

impl Handler<ProcStopResult> for SystemActor

impl<A> Handler<Signal> for A

where A: Actor,

We provide this handler to indicate that actors can handle the Signal message. Its actual handler is implemented by the runtime.

impl<A> Handler<Undeliverable<MessageEnvelope>> for A

where A: Actor,

This handler provides a default behavior when a message sent by the actor to another is returned due to delivery failure.

impl<A, M> Handler<IndexedErasedUnbound<M>> for A

where A: Handler<M>, M: Castable,

This handler enables actors to unbind the IndexedErasedUnbound message, and forward the result to corresponding handler.