lps 0.1.0

A local publish-subscribe pattern implementation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use lps::*;

use std::sync::Arc;

#[derive(Debug, Clone)]
struct TestMsg0(i32);

#[derive(Debug, Clone)]
struct TestMsg1(i32);

impl Message for TestMsg0 {}
impl Message for TestMsg1 {}

struct TestPublisher {
    msg_broker: Arc<dyn MessageBroker>,
}

impl TestPublisher {
    fn new(msg_broker: Arc<dyn MessageBroker>) -> Self {
        Self { msg_broker }
    }
}

impl Publisher for TestPublisher {
    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 TestSubsciber0 {
    sub: Subscription<TestMsg0>,
}

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

impl Subscriber for TestSubsciber0 {
    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<TestMsg0>| {
                println!("test_sub0.sub: {:?}", msg);
            })
            .run();
    }
}

struct TestSubsciber1 {
    sub: MultiSubscription,
}

impl TestSubsciber1 {
    fn new() -> Self {
        let mut multi_sub = MultiSubscription::unregistered();
        multi_sub.add::<TestMsg0>().add::<TestMsg1>();

        Self { sub: multi_sub }
    }
}

impl Subscriber for TestSubsciber1 {
    fn subscribe(&mut self, msg_broker: Arc<dyn MessageBroker>) {
        let _ = self.sub.register(Arc::clone(&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<TestMsg0>| {
                println!("test_sub1.sub0: {:?}", msg);
            })
            .handle(|msg: Arc<TestMsg1>| {
                println!("test_sub1.sub1: {:?}", msg);
            })
            .run();
    }
}

fn main() {
    let tb: Arc<dyn MessageBroker> = Arc::new(DefaultMessageBroker::new());

    let mut s0 = TestSubsciber0::new();
    s0.subscribe(Arc::clone(&tb));

    let mut s1 = TestSubsciber1::new();
    s1.subscribe(Arc::clone(&tb));

    let p0 = TestPublisher::new(Arc::clone(&tb));
    let p1 = TestPublisher::new(Arc::clone(&tb));

    p0.publish(Arc::new(TestMsg0(2)));
    s1.deactivate();
    p1.publish(Arc::new(TestMsg0(5)));
    s1.activate();
    p1.publish(Arc::new(TestMsg1(3)));
    p1.publish(Arc::new(TestMsg1(6)));

    s0.process_messages();
    s1.process_messages();
}