Struct BasicMediator 

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

Basic mediator for synchronous environments with events of type Ev.

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

Examples

Basic usage:

use mediator_sys::synchronous::basic::*;

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

struct Request(u32);

impl RequestHandler<Request, MyEvent> for BasicMediator<MyEvent> {
    fn handle(&self, req: Request) {
        match req.0 {
            1 => self.publish(MyEvent::One),
            2 => self.publish(MyEvent::Two),
            _ => ()
        };
    }
}

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

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

Trait Implementations

impl<Ev> BuilderFlow<BasicMediator<Ev>> for BasicBuilder<Ev>

where Ev: Debug,

fn build(self) -> BasicMediator<Ev>

Builds the BasicMediator and returns it.

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

impl<Ev> BuilderInternal<BasicMediator<Ev>, BasicBuilder<Ev>> for BasicMediator<Ev>

where Ev: Debug,

fn builder() -> BasicBuilder<Ev>

Creates a BasicBuilder with the goal of producing a BasicMediator.

impl<Ev> Debug for BasicMediator<Ev>

where Ev: Debug + Debug,

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

Formats the value using the given formatter.

impl<Ev> SyncMediatorInternal<Ev> for BasicMediator<Ev>

where Ev: Debug,

fn publish(&self, event: Ev)

Publishes an event Ev.

This method should be used within RequestHandler::handle() to publish a user-defined event.

Examples

Basic usage:

use mediator_sys::synchronous::basic::*;

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

struct Request(u32);

impl RequestHandler<Request, MyEvent> for BasicMediator<MyEvent> {
    fn handle(&self, req: Request) {
        match req.0 {
            1 => self.publish(MyEvent::One),
            2 => self.publish(MyEvent::Two),
            _ => ()
        };
    }
}

impl<Ev> SyncMediatorInternalHandle<Ev> for BasicMediator<Ev>

where Ev: Debug,

fn send<Req>(&self, req: Req)

where Self: RequestHandler<Req, Ev>,

Send a request of type Req to the mediator.

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

impl<Ev> SyncMediatorInternalNext for BasicMediator<Ev>

where Ev: Debug + Clone,

fn next(&self) -> Result<(), TryRecvError>

Process the next published event Ev.

SyncMediatorInternalNext::next() invokes registered listeners with a cloned value of the published event.