JFrame（EventBus——JBus提供插件间消息订阅和发布）

JBus，实现插件之间的消息订阅和发布！

JEvent

 1 #ifndef JEVENT_H
 2 #define JEVENT_H
 3 
 4 #include <QString>
 5 #include <QVariant>
 6 
 7 class JEvent
 8 {
 9 public:
10     JEvent(std::string _type, const QVariant &_var);
11     const std::string& getType();
12     const QVariant &getData();
13 private:
14     std::string m_type;
15     QVariant m_data;
16 };
17 
18 #endif // JEVENT_H

通过 Qvariant 保存数据！

JProxy

 1 #ifndef JPROXY_H
 2 #define JPROXY_H
 3 
 4 #include <memory>
 5 
 6 class JEvent;
 7 
 8 typedef void (*CALL_BACK_FUNC)(std::shared_ptr<JEvent> event, void *user);
 9 
10 class JProxy
11 {
12 public:
13     JProxy();
14     int getID();
15     void initialize(CALL_BACK_FUNC _func, void *_user);
16     void onReceive(std::shared_ptr<JEvent> _event);
17 private:
18     int m_id;
19     CALL_BACK_FUNC m_callBack = nullptr;
20     void *m_user = nullptr;
21 
22 };
23 
24 #endif // JPROXY_H

订阅列表

 1 #ifndef SUBSCRIPTIONLIST_H
 2 #define SUBSCRIPTIONLIST_H
 3 
 4 #include <QMutex>
 5 #include <map>
 6 #include "entity/jevent.h"
 7 #include "entity/jproxy.h"
 8 #include <memory>
 9 #include <list>
10 #include <mutex>
11 #include <condition_variable>
12 
13 class SubscriptionList
14 {
15 public:
16     SubscriptionList();
17     void addProxy(std::string _type, std::shared_ptr<JProxy> _proxy);
18     std::list<std::shared_ptr<JProxy>> getProxys(std::string _type);
19 private:
20     std::mutex m_mutex;
21     std::map<std::string, std::map<int, std::shared_ptr<JProxy>>> m_list;
22 };
23 
24 #endif // SUBSCRIPTIONLIST_H

事件队列

 1 #ifndef THREADSAFEQUEUE_H
 2 #define THREADSAFEQUEUE_H
 3 #include <queue>
 4 #include <limits>
 5 #include <mutex>
 6 #include <condition_variable>
 7 #include <memory>
 8 
 9 template<typename T>
10 class ThreadSafeQueue final
11 {
12 public:
13     using size_type = typename std::queue<T>::size_type;
14 
15     explicit ThreadSafeQueue(size_type queueSizeMax = std::numeric_limits<size_type>::max())
16     {
17         queueSizeMax_ = queueSizeMax;
18     }
19     ThreadSafeQueue(const ThreadSafeQueue& src) = delete;
20     ThreadSafeQueue& operator=(const ThreadSafeQueue& rhs) = delete;
21 
22     enum class TQueueResult
23     {
24         NoError = 0,
25         Full = -1
26     };
27 
28     size_type getMaxSize() const
29     {
30         return queueSizeMax_;
31     }
32     size_type getCurrentSize() const
33     {
34         std::lock_guard<std::mutex> scopeLock(mutex_);
35         return queue_.size();
36     }
37 
38     bool isFull() const
39     {
40         std::lock_guard<std::mutex> scopeLock(mutex_);
41         return queue_.size() == queueSizeMax_;
42     }
43     bool isEmpty()
44     {
45         std::lock_guard<std::mutex> scopeLock(mutex_);
46         return queue_.empty();
47     }
48 
49     TQueueResult push(const T &t)
50     {
51         std::lock_guard<std::mutex> scopeLock(mutex_);
52         if(queue_.size() >= queueSizeMax_)
53         {
54             return ThreadSafeQueue<T>::TQueueResult::Full;
55         }
56 
57         queue_.push(t);
58         return ThreadSafeQueue<T>::TQueueResult::NoError;
59     }
60 
61     T pop()
62     {
63         std::lock_guard<std::mutex> scopeLock(mutex_);
64         if(!queue_.empty())
65         {
66             T _t = queue_.front();
67             queue_.pop();
68             return _t;
69         }
70         return T();
71     }
72 
73 private:
74     std::queue<T> queue_;
75     size_type queueSizeMax_;
76 
77     std::mutex mutex_;
78 };
79 
80 #endif // THREADSAFEQUEUE_H

发布和订阅

 1 void MainWindow::on_publishPushButton_clicked()
 2 {
 3     JEvent *event = new JEvent("testType", QVariant(QString("hello JBus！！！")));
 4     JBus::getInstance()->Publish(std::shared_ptr<JEvent>(event));
 5 }
 6 
 7 void MainWindow::on_registPushButton_clicked()
 8 {
 9     JBus::getInstance()->Regist(onResponse, this, "testType");
10 }

 

posted @ 2022-04-15 22:34  SSSnail  阅读(70)  评论(0)    收藏  举报