Struct bottles::dispatcher::Dispatcher

pub struct Dispatcher { /* fields omitted */ }

Dispatches messages among subscribers

A subscriber is a closure which takes exactly one argument: Rc<T> where T is the type of message to receive.

Dispatcher is type safe by having a mapping of the subscriber's expected type TypeId's and the closures handling them.

Methods

impl Dispatcher

pub fn new() -> Self

Creates a new Dispatcher.

pub fn register<T: 'static>(&mut self)

Registers the type to be available for subscribing

It is a design choice that subscribing for a message of type that has not yet been registered will result in a panic (error in the future).

Safety

This function uses unsafe internally, because of the need of mapping a Rc<T> into a *const () for homogeneous storage.

The transmutation fo *const () is done in a closure that knows the target type Rc<T> and the usage is safe because the Dispatcher type holds a mapping between a TypeId and the corresponding closure which deals with the type itself.

pub fn subscribe<F, T>(&mut self, f: F) where
    F: FnMut(Rc<T>) + 'static,
    T: 'static, 

Adds a subscriber for a message of type T. Whenever a value of type Rc<T> will be dispatched the provided callback will be executed.

Example

use bottles::dispatcher::Dispatcher;

struct Message {}

let mut dispatcher = Dispatcher::new();
dispatcher.register::<Message>();
dispatcher.subscribe(|message: Rc<Message>| {
    // react to the message
});

pub fn dispatch<T: 'static>(&mut self, msg: Rc<T>)

Dispatches the message of value T to all of the subscribers

Safety

This method casts untyped *const () message received internally into the expected type. It is safe to be called because of the mapping that ensures the correct messages are distributed to subscribers expecting them.