Trait EventConsumer 

pub trait EventConsumer<E: Event>:
    Send
    + Sync
    + 'static {
    type Error: Error + Send + Sync + Sized + 'static;

    // Required methods
    fn accept<'life0, 'async_trait>(
        &'life0 self,
        event: E,
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn accept_sync(&self, event: E) -> Result<(), Self::Error>;
}

The inbox side of an Actor

Required Associated Types

type Error: Error + Send + Sync + Sized + 'static

The error type for this event consumer

Required Methods

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

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

Accepts an event

This method can run long running computation, but is strongly encouraged to properly utilize the blocking thread pool.

Errors

Will return an error if communication with the actor fails

fn accept_sync(&self, event: E) -> Result<(), Self::Error>

Accepts an event, blocking if needed

Errors

Will return an error if communication with the actor fails

Implementations on Foreign Types

impl<E: Event> EventConsumer<E> for Sender<E>

type Error = SendError<E>

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

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

fn accept_sync(&self, event: E) -> Result<(), Self::Error>

impl<E: Event, F, H> EventConsumer<E> for (F, H)

where F: Fn(&E::Flags, &E) -> bool + Send + Sync + 'static, H: Fn(E) + Send + Sync + 'static,

type Error = Infallible

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

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

fn accept_sync(&self, event: E) -> Result<(), Self::Error>

Implementors

impl<E: Event, C: EventConsumer<E>> EventConsumer<E> for DynamicConsumer<E, C>

type Error = DynamicError

impl<I: Event, O: Event, C: EventConsumer<O>> EventConsumer<I> for Adaptor<I, O, C>

type Error = <C as EventConsumer<O>>::Error

impl<X: Executor, I: Event, O: Event> EventConsumer<I> for AsyncActor<I, O, X>

type Error = AsyncActorError

impl<X: Executor, I: Event, O: Event> EventConsumer<I> for SyncActor<I, O, X>

type Error = SyncActorError