Struct DefaultMediator 

pub struct DefaultMediator { /* private fields */ }

A default implementation for the Mediator trait.

Examples

Request handler

use std::sync::atomic::AtomicU64;
use mediator::{DefaultMediator, Mediator, Request, RequestHandler};

struct GetNextId;
impl Request<u64> for GetNextId { }

struct GetNextIdHandler;
impl RequestHandler<GetNextId, u64> for GetNextIdHandler {
  fn handle(&mut self, _: GetNextId) -> u64 {
    static NEXT_ID : AtomicU64 = AtomicU64::new(1);
    NEXT_ID.fetch_add(1, std::sync::atomic::Ordering::SeqCst)
  }
}

let mut mediator = DefaultMediator::builder()
    .add_handler(GetNextIdHandler)
    .build();

assert_eq!(Ok(1), mediator.send(GetNextId));
assert_eq!(Ok(2), mediator.send(GetNextId));
assert_eq!(Ok(3), mediator.send(GetNextId));

Event handler

use mediator::{Event, DefaultMediator, Mediator};

#[derive(Clone)]
struct Product { name: String };

#[derive(Clone)]
struct ProductAddedEvent(Product);
impl Event for ProductAddedEvent { }

struct ProductService(Vec<Product>, DefaultMediator);
impl ProductService {
    pub fn add<S: Into<String>>(&mut self, product: S) {
        let product = Product { name: product.into() };
        self.0.push(product.clone());
        self.1.publish(ProductAddedEvent(product));
    }
}

let mut mediator = DefaultMediator::builder()
    .subscribe_fn(move |event: ProductAddedEvent| {
        println!("Product added: {}", event.0.name);
    })
   .build();

let mut service = ProductService(vec![], mediator.clone());

service.add("Microwave");   // Product added: Microwave
service.add("Toaster");     // Product added: Toaster

Implementations

impl DefaultMediator

pub fn builder() -> Builder

Gets a DefaultMediator builder.

Trait Implementations

impl Clone for DefaultMediator

fn clone(&self) -> DefaultMediator

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Mediator for DefaultMediator

fn send<Req, Res>(&mut self, req: Req) -> Result<Res>

where Res: 'static, Req: Request<Res> + 'static,

Sends a request to the mediator.

fn publish<E>(&mut self, event: E) -> Result<()>

where E: Event + 'static,

Publish an event to the mediator.