lps

A local publish-subscribe pattern implementation

Example

```rust use lps::*;

use std::sync::Arc;

[derive(Debug, Clone, Copy)]

struct Msg(i32);

impl Message for Msg {}

struct Pub { msg_broker: Arc, }

impl Pub { fn new(msgbroker: Arc) -> Self { Self { msgbroker } } }

impl Publisher for Pub { fn messagebroker(&self) -> Arc { Arc::clone(&self.msgbroker) }

fn set_message_broker(&mut self, msg_broker: Arc<dyn MessageBroker>) {
    self.msg_broker = msg_broker;
}

}

struct Sub { sub: Subscription, }

impl Sub { fn new() -> Self { Self { sub: Subscription::unregistered(), } } }

impl Subscriber for Sub { fn subscribe(&mut self, msgbroker: Arc) { let _ = self.sub.register(msgbroker); }

fn unsubscribe(&mut self) {
    let _ = self.sub.unregister();
}

fn activate(&self) {
    let _ = self.sub.activate();
}

fn deactivate(&self) {
    let _ = self.sub.deactivate();
}

fn process_messages(&mut self) {
    self.sub
        .message_iter()
        .handle(|msg: Arc<Msg>| {
            println!("The subscriber received a message: {:?}", msg);
        })
        .run();
}

}

let msg_broker: Arc = Arc::new(DefaultMessageBroker::new());

let mut s = Sub::new(); s.subscribe(Arc::clone(&msg_broker));

let p = Pub::new(Arc::clone(&msg_broker));

p.publish(Arc::new(Msg(1))); p.publish(Arc::new(Msg(2))); p.publish(Arc::new(Msg(3)));

s.process_messages();

```