Struct mediator_sys::asynchronous::basic::BasicAsyncMediator

pub struct BasicAsyncMediator<Ev>where
    Ev: Debug,{ /* private fields */ }

Available on crate feature async only.

Basic async mediator for asynchronous environments with events of type Ev.

A BasicAsyncMediator is constructed through its builder. It receives requests through its AsyncMediatorInternalHandle::send() interface, which are processed by the user-defined AsyncRequestHandler implementation. From within this async handler, events of type Ev can be published using the BasicAsyncMediator::publish() functionality. Listeners injected with super::BasicAsyncBuilder::add_listener() are invoked when the user calls BasicAsyncMediator::next().

Examples

Basic usage:

use mediator_sys::asynchronous::basic::*;
use async_trait::async_trait;
use async_std;

#[derive(Debug, Clone)]
enum MyEvent {
    One,
    Two
}

struct Request(u32);

#[async_trait]
impl AsyncRequestHandler<Request, MyEvent> for BasicAsyncMediator<MyEvent> {
    async fn handle(&self, req: Request) {
        match req.0 {
            1 => self.publish(MyEvent::One).await,
            2 => self.publish(MyEvent::Two).await,
            _ => ()
        };
    }
}

async_std::task::block_on(async {
    let mediator = BasicAsyncMediator::<MyEvent>::builder()
        .add_listener(move |ev| {
            /* Your listening logic */
        })
        .add_listener(move |ev| {
            /* Your listening logic */
        })
        .build();

    mediator.send(Request(1)).await;
    mediator.next().await.ok();
});

Trait Implementations

impl<Ev> AsyncMediatorInternal<Ev> for BasicAsyncMediator<Ev>where
    Ev: Debug + Send,

fn publish<'life0, 'async_trait>(
    &'life0 self,
    event: Ev
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Publishes an event Ev asynchronously.

This method locks the Mutex and instructs the underlying BasicMediator to publish an event. Best used within AsyncRequestHandler::handle().

You need to await the Future using .await.

Examples

Basic usage:

use mediator_sys::asynchronous::basic::*;
use async_trait::async_trait;

#[derive(Debug, Clone)]
enum MyEvent {
    One,
    Two
}

struct Request(u32);

#[async_trait]
impl AsyncRequestHandler<Request, MyEvent> for BasicAsyncMediator<MyEvent> {
    async fn handle(&self, req: Request) {
        match req.0 {
            1 => self.publish(MyEvent::One).await,
            2 => self.publish(MyEvent::Two).await,
            _ => ()
        };
    }
}

impl<Ev> AsyncMediatorInternalHandle<Ev> for BasicAsyncMediator<Ev>where
    Ev: Debug,

fn send<'life0, 'async_trait, Req>(
    &'life0 self,
    req: Req
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
    Self: AsyncRequestHandler<Req, Ev>,
    Req: Send,
    Req: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait,

Send a request of type Req to the mediator asynchronously.

The request will be processed internally by AsyncRequestHandler::handle(). This is why it is required to implement AsyncRequestHandler for BasicAsyncMediator.

You need to await the Future using .await.

impl<Ev> AsyncMediatorInternalNext for BasicAsyncMediator<Ev>where
    Ev: Debug + Clone + Send,

fn next<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), TryRecvError>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Process the next published event Ev asynchronously.

This method locks the Mutex and instructs the underlying BasicMediator to process the next event.

See BasicMediator::next() for more info.

You need to await the Future using .await.

impl<Ev> BuilderFlow<BasicAsyncMediator<Ev>> for BasicAsyncBuilder<Ev>where
    Ev: Debug,

fn build(self) -> BasicAsyncMediator<Ev>

Builds the BasicAsyncMediator and returns it.

Because BasicAsyncMediator implements BuilderInternal, which in turn means, that the BasicAsyncBuilder implements BuilderFlow and not crate::builder::TryBuilderFlow, this method will always return a BasicAsyncMediator as stated by the return type.

impl<Ev> BuilderInternal<BasicAsyncMediator<Ev>, BasicAsyncBuilder<Ev>> for BasicAsyncMediator<Ev>where
    Ev: Debug,

fn builder() -> BasicAsyncBuilder<Ev>

Creates a BasicAsyncBuilder with the goal of producing a BasicAsyncMediator.

impl<Ev: Debug> Debug for BasicAsyncMediator<Ev>where
    Ev: Debug,

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

Formats the value using the given formatter.