sascha
/
query
1
0
Fork 0
Code Issues 4 Pull Requests Actions Packages Projects Releases Wiki Activity

formatting amd naming issues in message_bus.hpp

This commit is contained in:
Sascha Kühl 2026-02-09 13:04:36 +01:00
parent 54e6786ceb
commit cf977a32aa
1 changed files with 34 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
include/matador/utils/message_bus.hpp
View File

@ -93,7 +93,9 @@ public:
* @return True if the object matches the type, false otherwise.
*/
template<typename MessageType>
[[nodiscard]] bool is() const { return type_ == std::type_index(typeid(MessageType)); }
[[nodiscard]] bool is() const {
return type_ == std::type_index(typeid(MessageType));
}
/**
* @brief Accesses the stored object as a typed reference.
@ -105,10 +107,14 @@ public:
*/
template<typename MessageType>
const MessageType& get() const {
if (!is<MessageType>()) throw std::bad_cast();
const void* p = raw_ptr();
if (!p) throw std::runtime_error("AnyMessage: empty pointer");
return *static_cast<const MessageType*>(p);
if (!is<MessageType>()) {
throw std::bad_cast();
}
const void* ptr = raw_ptr();
if (!ptr) {
throw std::runtime_error("AnyMessage: empty pointer");
}
return *static_cast<const MessageType*>(ptr);
}
/**
@ -209,26 +215,24 @@ public:
* @return A subscription object to manage the handler's registration.
*/
template<typename MessageType>
subscription subscribe(std::function<void(const MessageType&)> handler,
Filter<MessageType> filter = nullptr)
{
subscription subscribe(std::function<void(const MessageType&)> handler, Filter<MessageType> filter = nullptr) {
auto id = next_id_.fetch_add(1, std::memory_order_relaxed);
std::unique_lock writeLock(mutex_);
std::unique_lock write_lock(mutex_);
auto &vec = handlers_[std::type_index(typeid(MessageType))];
Entry e;
e.id = id;
e.handler = [h = std::move(handler)](const void* p) {
Entry entry;
entry.id = id;
entry.handler = [h = std::move(handler)](const void* p) {
h(*static_cast<const MessageType*>(p));
};
if (filter) {
e.filter = [f = std::move(filter)](const void* p) -> bool {
entry.filter = [f = std::move(filter)](const void* p) -> bool {
return f(*static_cast<const MessageType*>(p));
};
} else {
e.filter = nullptr;
entry.filter = nullptr;
}
vec.emplace_back(std::move(e));
vec.emplace_back(std::move(entry));
return {this, std::type_index(typeid(MessageType)), id};
}
@ -245,8 +249,7 @@ public:
template<typename MessageType, typename CallerClass>
subscription subscribe(CallerClass* instance,
MemberHandler<MessageType, CallerClass> memberFn,
Filter<MessageType> filter = nullptr)
{
Filter<MessageType> filter = nullptr) {
auto fn = [instance, memberFn](const MessageType& m) { (instance->*memberFn)(m); };
return subscribe<MessageType>(std::function<void(const MessageType&)>(fn), std::move(filter));
}
@ -257,29 +260,28 @@ public:
* @tparam MessageType The type of the message to subscribe to.
* @tparam CallerClass The class of the shared_ptr instance.
* @param instance A shared pointer to the instance.
* @param memberFn A pointer to the member function to execute.
* @param member_func A pointer to the member function to execute.
* @param filter An optional filter function.
* @return A subscription object to manage the handler's registration.
*/
template<typename MessageType, typename CallerClass>
subscription subscribe(std::shared_ptr<CallerClass> instance,
MemberHandler<MessageType, CallerClass> memberFn,
Filter<MessageType> filter = nullptr)
{
std::weak_ptr<CallerClass> w = instance;
auto handler = [w, memberFn](const MessageType& m) {
if (auto s = w.lock()) {
(s.get()->*memberFn)(m);
MemberHandler<MessageType, CallerClass> member_func,
Filter<MessageType> filter = nullptr) {
std::weak_ptr<CallerClass> caller_ptr = instance;
auto handler = [caller_ptr, member_func](const MessageType& msg) {
if (auto caller = caller_ptr.lock()) {
(caller.get()->*member_func)(msg);
}
};
std::function<bool(const MessageType&)> local_filter = nullptr;
if (filter) {
local_filter = [w, filter = std::move(filter)](const MessageType& m) -> bool {
if (w.expired()) {
local_filter = [caller_ptr, filter = std::move(filter)](const MessageType& msg) -> bool {
if (caller_ptr.expired()) {
return false;
}
return filter(m);
return filter(msg);
};
}
return subscribe<MessageType>(std::move(handler), std::move(local_filter));
@ -321,7 +323,7 @@ public:
void publish(const MessageType& msg) const {
std::vector<Entry> snapshot;
{
std::shared_lock readLock(mutex_);
std::shared_lock read_lock(mutex_);
const auto it = handlers_.find(std::type_index(typeid(MessageType)));
if (it == handlers_.end()) {
return;
@ -329,7 +331,9 @@ public:
snapshot = it->second; // copy list to avoid holding lock during callbacks
}
for (const auto &e : snapshot) {
if (!e.filter || e.filter(&msg)) e.handler(&msg);
if (!e.filter || e.filter(&msg)) {
e.handler(&msg);
}
}
}