Simple semi-compile-time 'event-bus' in c++ - c++

Question

I am trying to hide serious design flaws in my application behind event bus :)
I created template class with static event handlers holder like this:
template<typename ET>
class EventHandler;
template<typename ET>
class EventBus {
public:
static std::vector<EventHandler<ET>*> handlers;
};
template<typename ET>
std::vector<EventHandler<ET>*> EventBus<ET>::handlers = std::vector<EventHandler<ET>*>();
Next part of my 'event-bus' is template class for event handler:
template<typename ET>
class EventHandler {
public:
EventHandler() {
EventBus<ET>::handlers.emplace_back(this);
}
~EventHandler() {
auto &handlers=EventBus<ET>::handlers;
handlers.erase(std::remove(handlers.begin(), handlers.end(), this), handlers.end());
}
virtual void handle_event(ET &event) = 0;
};
Here is a complete code with example usage:
#include <iostream>
#include <vector>
#include <map>
template<typename ET>
class EventHandler;
template<typename ET>
class EventBus {
public:
static std::vector<EventHandler<ET>*> handlers;
};
template<typename ET>
std::vector<EventHandler<ET>*> EventBus<ET>::handlers = std::vector<EventHandler<ET>*>();
template<typename ET>
class EventHandler {
public:
EventHandler() {
EventBus<ET>::handlers.emplace_back(this);
}
~EventHandler() {
auto &handlers=EventBus<ET>::handlers;
handlers.erase(std::remove(handlers.begin(), handlers.end(), this), handlers.end());
}
virtual void handle_event(ET &event) = 0;
};
template<typename ET>
void publish(ET &event) {
for(auto handler : EventBus<ET>::handlers) {
handler->handle_event(event);
}
}
class MyClass: public EventHandler<int>, public EventHandler<std::string> {
public:
void handle_event(int &event) override {
std::cout << "handling int event" << std::endl;
}
void handle_event(std::string &event) override {
std::cout << "handling std::string event" << std::endl;
}
};
int main() {
int eventData = 1;
MyClass eventHandler2;
std::string stringEventData = "hello, world";
{
MyClass eventHandler;
publish(eventData);
publish(stringEventData);
}
publish(eventData);
publish(stringEventData);
std::cout << "Hello, World!" << std::endl;
return 0;
}
So the question is - is there some chance that I will have issues with resolving correct handle_event method based on event type with mulptiple inheritance?

Answer 1

There won't be any issues resolving the handle_event overload with the given publish() function, because only one handle_event member function is actually visible in this function: the type being invoked on is EventHandler<ET>, which only knows about handle_event(ET&) (whatever ET happens to be).
For example, if ET is int, this function doesn't even see the handle_event(std::string&) overload because that overload isn't part of the EventHandler<int> interface.