Struct CxAwareAsyncMediator 

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

Available on crate feature async only.

Context aware async mediator for asynchronous environments with events of type Ev.

Uses an underlying BasicAsyncMediator for base functionality and a Mutex to store the user-defined dependency Dep.

Examples

Basic usage:

use mediator_sys::asynchronous::contextaware::*;
use std::sync::Arc;
use async_trait::async_trait;
use async_std;

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

#[derive(Debug, Default)]
struct MyContext(Arc<u32>);

struct Request(u32);

#[async_trait]
impl CxAwareAsyncRequestHandler<MyContext, Request, MyEvent> for CxAwareAsyncMediator<MyContext, MyEvent> {
    async fn handle(&self, req: Request, dep: &MyContext) {
        let my_context: u32 = *dep.0;
        match req.0 {
            1 => self.publish(MyEvent::One).await,
            2 => self.publish(MyEvent::Two).await,
            _ => ()
        };
    }
}

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

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

Trait Implementations

impl<Dep, Ev> AsyncMediatorInternal<Ev> for CxAwareAsyncMediator<Dep, Ev>

where Dep: Debug + Send, Ev: Debug + Send,

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

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

Publishes an event Ev asynchronously.

This method instructs the underlying BasicAsyncMediator to publish a user-defined event.

It should be used within CxAwareAsyncRequestHandler::handle().

You need to await the Future using .await.

Examples

Basic usage:

use mediator_sys::asynchronous::contextaware::*;
use async_trait::async_trait;
use std::sync::Arc;

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

#[derive(Debug, Default)]
struct MyContext(Arc<u32>);

struct Request(u32);

#[async_trait]
impl CxAwareAsyncRequestHandler<MyContext, Request, MyEvent> for CxAwareAsyncMediator<MyContext, MyEvent> {
    async fn handle(&self, req: Request, dep: &MyContext) {
        let my_context: u32 = *dep.0;
        match req.0 {
            1 => self.publish(MyEvent::One).await,
            2 => self.publish(MyEvent::Two).await,
            _ => ()
        };
    }
}

impl<Dep, Ev> AsyncMediatorInternalNext for CxAwareAsyncMediator<Dep, Ev>

where Dep: Debug + Send, Ev: Debug + Clone + Send,

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

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

Process the next published event Ev asynchronously.

This method instructs the underlying BasicAsyncMediator to process the next event.

See BasicAsyncMediator::next() for more info.

You need to await the Future using .await.

impl<Dep, Ev> CxAwareAsyncMediatorInternalHandle<Dep, Ev> for CxAwareAsyncMediator<Dep, Ev>

where Dep: Debug + Send + Sync, Ev: Debug + Send,

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

where Self: CxAwareAsyncRequestHandler<Dep, Req, Ev> + 'async_trait, Req: Send + 'async_trait, 'life0: 'async_trait,

Send a request of type Req to the mediator asynchronously.

The request will be processed internally by CxAwareAsyncRequestHandler::handle(). This is why it is required to implement CxAwareAsyncRequestHandler for CxAwareAsyncMediator. A Mutex will be locked in order to gain access to the context Dep.

You need to await the Future using .await.

impl<Dep, Ev> Debug for CxAwareAsyncMediator<Dep, Ev>

where Dep: Debug + Debug, Ev: Debug + Debug,

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

Formats the value using the given formatter.

impl<Dep, Ev> TryBuilderFlow<CxAwareAsyncMediator<Dep, Ev>> for CxAwareAsyncBuilder<Dep, Ev>

where Dep: Debug, Ev: Debug,

fn build(self) -> Result<CxAwareAsyncMediator<Dep, Ev>, Self::Error>

Builds the CxAwareAsyncMediator and returns it.

Because CxAwareAsyncMediator implements TryBuilderInternal, which in turn means, that the CxAwareAsyncBuilder implements TryBuilderFlow this method will return a [Result<CxAwareAsyncMediator<Dep, Ev>, Self::Error>] as stated by the return type. Note that here Self::Error is of type NoCxAvailable, which means that no dependecy was added in the process of building.

type Error = NoCxAvailable

impl<Dep, Ev> TryBuilderInternal<CxAwareAsyncMediator<Dep, Ev>, CxAwareAsyncBuilder<Dep, Ev>> for CxAwareAsyncMediator<Dep, Ev>

where Dep: Debug, Ev: Debug,

fn builder() -> CxAwareAsyncBuilder<Dep, Ev>

Creates a CxAwareAsyncBuilder with the goal of producing a CxAwareAsyncMediator.