Crate lps

A local publish-subscribe pattern implementation.

Example

use lps::*;
 
use std::sync::Arc;
 
#[derive(Debug, Clone, Copy)]
struct Msg(i32);
 
impl Message for Msg {}
 
struct Pub {
    msg_broker: Arc<dyn MessageBroker>,
}
 
impl Pub {
    fn new(msg_broker: Arc<dyn MessageBroker>) -> Self {
        Self { msg_broker }
    }
}
 
impl Publisher for Pub {
    fn message_broker(&self) -> Arc<dyn MessageBroker> {
        Arc::clone(&self.msg_broker)
    }
 
    fn set_message_broker(&mut self, msg_broker: Arc<dyn MessageBroker>) {
        self.msg_broker = msg_broker;
    }
}
 
struct Sub {
    sub: Subscription<Msg>,
}
 
impl Sub {
    fn new() -> Self {
        Self {
            sub: Subscription::unregistered(),
        }
    }
}
 
impl Subscriber for Sub {
    fn subscribe(&mut self, msg_broker: Arc<dyn MessageBroker>) {
        let _ = self.sub.register(msg_broker);
    }
 
    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<dyn MessageBroker> = 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();
 

Macros

match_message

Downcasts Arc<dyn Message> to the one of the given types and runs the code which corresponds to it.

Structs

DefaultMessageBroker

HandleMessage

A message iterator which handles messages with f.

MessageHandler

A function for handling messages of specific type.

MessageIter

An iterator which yields messages from one ErasedSubscription.

MessageTopic

MessageTypeId

The type id of the message.

MultiSubscription

Subscription

A type which is used for receiving messages of a specific type from the message broker.

Enums

MessageBrokerError

MessageHandlerError

MessageTopicError

SubscriptionError

Traits

ErasedMessageHandler

A function with erased type for handling messages.

ErasedSubscription

A Subscription with and erased message type.

IntoMessageHandler

A type which can be converted into a ErasedMessageHandler.

Message

A type which is used for communicating between publishers and subscribers.

MessageBroker

A type which delivers messages from publishers to subscribers.

MessageIterator

An iterator which yields messages.

Publisher

A sender of messages.

Subscriber

A receiver of messages.