How call a method on all step of class derivation hierarchy? - c++

Question

Take this example:
#include <iostream>
#include <typeindex>
#include <vector>
#include <map>
class _IEventHandler {}; // just for abstract template type
class IEvent {
public:
virtual void visitEventHandler(_IEventHandler *handler) = 0;
};
#define EXTENDS(type, parentType) \
public: \
using ParentClass = parentType; \
void visitEventHandler(_IEventHandler* handler) override { \
static_cast<IEventHandler<type>*>(handler)->on(*this); \
} \
template<typename Event>
class IEventHandler : public _IEventHandler {
public:
//virtual void on(Event& e) = 0;
void on(Event &e) {
std::cout << "handle " << typeid(Event).name() << std::endl;
}
};
class EventA : public IEvent {
EXTENDS(EventA, IEvent)
};
class EventB : public EventA {
EXTENDS(EventB, EventA)
};
class EventC : public EventB {
EXTENDS(EventC, EventB)
};
class EventD : public EventC {
EXTENDS(EventD, EventC)
};
class EventBus {
public:
void fire(IEvent *event) {
while (typeid(*event) != typeid(IEvent)) {
for (_IEventHandler *handler : m_handlers[typeid(*event)])
event->visitEventHandler(handler);
// Need to update event so the loop progresses. Need to upper cast?
}
}
template<typename T>
void hook(IEventHandler<T> *handler) {
m_handlers[typeid(T)].push_back(handler);
}
protected:
std::map<std::type_index, std::vector<_IEventHandler *>> m_handlers{};
};
int main() {
EventBus eb{};
IEventHandler<EventD> ehd{};
IEventHandler<EventC> ehc{};
IEventHandler<EventA> eha{};
eb.hook(&ehd);
eb.hook(&ehc);
eb.hook(&eha);
EventD eD{};
EventB eB{};
eb.fire(&eD); // need to stdout handle EventD handle EventC handle EventA
eb.fire(&eB); // need to stdout handle EventA
return 0;
}
I would like when I fire a IEvent it call on(EventX& e) on all intermediate derived class and stop on abstract class IEvent.
Currently I don't find solution, I looked about dyn_cast with a typeid, using decltype to access a static method from a instance (yes it's not the basic usage of these operators ;) and not permitted).
Summary:
The goal is to build an event system that supports hooking handlers and firing events. Events are hierarchical, deriving from a common ancestor class. Handlers should be called for their nominal event type and all types derived from that.
So far, the EventBus class is able to call handlers for the specific event type that was fired. The handlers are organized in a map from type_index to a vector of handlers. Getting the entry for a specific event type is not a problem, but how to get the less-derived types?

Answer 1

This is currently solve my issue:
#include <iostream>
#include <typeindex>
#include <vector>
#include <map>
class _IEventHandler {}; // just for abstract template type
class IEvent {
public:
virtual void visit_IEventHandler(std::type_index _index, _IEventHandler *handler) {}
virtual std::type_index getParentTypeIndex(std::type_index index) {
return typeid(IEvent);
}
};
#define EXTENDS(type, parentType) \
public: \
using Class = type; \
using ParentClass = parentType; \
std::type_index getParentTypeIndex(std::type_index index) { \
if (index == typeid(type)) \
return typeid(ParentClass); \
else \
return ParentClass::getParentTypeIndex(index); \
} \
#define HIERARCHICAL_VISITOR(interfaceType, reelType, methodName) \
public: \
void visit##interfaceType(std::type_index _index, interfaceType* _instanceToVisit) override { \
if (_index == typeid(Class)) \
static_cast<reelType<Class>*>(_instanceToVisit)->methodName(*this); \
else \
ParentClass::visit##interfaceType(_index, _instanceToVisit); \
} \
template<typename Event>
class IEventHandler : public _IEventHandler {
public:
//virtual void on(Event& e) = 0;
void on(Event &e) {
std::cout << "handle " << typeid(Event).name() << std::endl;
}
};
class EventA : public IEvent {
EXTENDS(EventA, IEvent)
HIERARCHICAL_VISITOR(_IEventHandler, IEventHandler, on)
};
class EventB : public EventA {
EXTENDS(EventB, EventA)
HIERARCHICAL_VISITOR(_IEventHandler, IEventHandler, on)
};
class EventC : public EventB {
EXTENDS(EventC, EventB)
HIERARCHICAL_VISITOR(_IEventHandler, IEventHandler, on)
};
class EventD : public EventC {
EXTENDS(EventD, EventC)
HIERARCHICAL_VISITOR(_IEventHandler, IEventHandler, on)
};
class EventBus {
public:
void fire(IEvent *event) {
std::type_index index = typeid(*event);
while (index != typeid(IEvent)) {
for (_IEventHandler *handler : m_handlers[index])
event->visit_IEventHandler(index, handler);
index = event->getParentTypeIndex(index);
}
}
template<typename T>
void hook(IEventHandler<T> *handler) {
m_handlers[typeid(T)].push_back(handler);
}
protected:
std::map<std::type_index, std::vector<_IEventHandler *>> m_handlers{};
};
int main() {
EventBus eb{};
IEventHandler<EventD> ehd{};
IEventHandler<EventC> ehc{};
IEventHandler<EventA> eha{};
eb.hook(&ehd);
eb.hook(&ehc);
eb.hook(&eha);
EventD eD{};
EventB eB{};
eb.fire(&eD); // need to stdout handle EventD handle EventC handle EventA
eb.fire(&eB); // need to stdout handle EventA
return 0;
}
/*
handle 6EventD
handle 6EventC
handle 6EventA
handle 6EventA
Process finished with exit code 0
*/
The only way that I found is use the basic inheritance process with the typeid check at all stage. I don't know if is the best way, I looking for a better way ;)

Answer 2

The keywords for this answer are "simplify" and "encapsulate".
Let's start with simplifications. There are several elements of the question's code that serve no purpose other than making the code more complicated than it needs to be. (There might be a small performance benefit, but it is premature to worry about that.) In order to better see what the actual solution is, I think it is useful to include these improvements. On the other hand, these are only indirectly related to the actual solution, so I will refrain from giving a detailed rationale for each of these.
Rename _IEventHandler to BaseEventHandler to comply with naming requirements.
Make on() a virtual function in BaseEventHandler so that visitEventHandler() does not need a static_cast.
Make visitEventHandler() a non-virtual function since all implementations are now the same.
Declare ~IEvent() to be virtual so that IEvent still has a virtual function.
Remove the EXTENDS macro because (macros are evil and) the things it defines are no longer used.
Moving on to encapsulation, let's look at the problem from the point of view of EventBus. This class is responsible for triggering handlers in response to events. It has inferred which event each handler wants, and organized the handlers by those event types. This already breaks encapsulation a bit since the bus uses knowledge about the handler's innards. Now they want me to also know about inheritance among the event types??? I need more information or you can go handle it yourself!
Since encapsulation encourages less information, rather than more, let's consider the other option: handle it yourself! Er, let the handlers decide if they want to handle an event. This simplifies EventBus since it no longer needs to be concerned about event types. Its map containing vectors can become a single vector, its hook() method no longer needs to be a template, and its fire() method can drop the loop that has been so difficult to implement. The trade-off is that the event handlers now need to examine the event types. Fortunately, dynamic_cast makes the check very simple.
#include <iostream>
#include <vector>
#include <map>
class IEvent;
/* ** Event handler ** */
class BaseEventHandler {
public:
virtual void on(IEvent &) = 0;
};
template<typename Event>
class IEventHandler : public BaseEventHandler {
public:
void on(IEvent & e) override {
// Only fire for events of the templated type.
if ( dynamic_cast<Event *>(&e) )
std::cout << "handle " << typeid(Event).name() << std::endl;
}
};
/* ** Event ** */
class IEvent {
public:
virtual ~IEvent() {} // To force run time type information (RTTI)
void visitEventHandler(BaseEventHandler* handler)
{
handler->on(*this);
}
};
class EventA : public IEvent {};
class EventB : public EventA {};
class EventC : public EventB {};
class EventD : public EventC {};
/* ** Event Bus ** */
class EventBus {
public:
void fire(IEvent *event) {
for (BaseEventHandler *handler : m_handlers)
event->visitEventHandler(handler);
}
void hook(BaseEventHandler *handler) {
m_handlers.push_back(handler);
}
protected:
std::vector<BaseEventHandler *> m_handlers{};
};
int main() {
EventBus eb{};
IEventHandler<EventD> ehd{};
IEventHandler<EventC> ehc{};
IEventHandler<EventA> eha{};
eb.hook(&ehd);
eb.hook(&ehc);
eb.hook(&eha);
EventD eD{};
EventB eB{};
std::cout << "Firing event D.\n";
eb.fire(&eD); // need to stdout handle EventD handle EventC handle EventA
std::cout << "\nFiring event B.\n";
eb.fire(&eB); // need to stdout handle EventA
return 0;
}
Some things to note about this approach:
Event handlers are fired in the order in which they were hooked. Previously, the order was handlers for the most derived class in the order they were hooked, followed by handlers for that class's direct parent in the order they were hooked, etc. If this is an important consideration, see my other answer.
There are still some issues with this code, but I am willing to chalk them up to being artifacts arising from the need to minimize the example.
There is no need to #include <typeindex>! This is good. I consider use of that header to be a yellow flag for design flaws. Better than a red flag (such as macros), but still an indication that maybe there's a better way to do things.

Answer 3

The keywords for this answer are "simplify" and "delegate".
Let's start with simplifications. There are several elements of the question's code that serve no purpose other than making the code more complicated than it needs to be. (There might be a small performance benefit, but it is premature to worry about that.) In order to better see what the actual solution is, I think it is useful to include these improvements. On the other hand, these are only indirectly related to the actual solution, so I will refrain from giving a detailed rationale for each of these.
Rename _IEventHandler to BaseEventHandler to comply with naming requirements.
Make on() a virtual function in BaseEventHandler so that visitEventHandler() does not need a static_cast.
Remove the EXTENDS macro because (macros are evil and) the things it defines either are no longer used or will be defined elsewhere.
Moving on to delegation, let's look at why EventBus has trouble traversing the inheritance tree of events. One reason is straight-forward: EventBus is not an event. Instead of trying to replicate the inheritance tree, let's use existing elements of the language. Instead of trying to deduce things about events, let's hand the problem off to someone who knows better, namely the event itself.
What I have in mind is a shift of responsibilities, basically shifting most of EventBus::fire() to the events' visitEventHandler(). Since each class knows its parent, it can invoke its parent's version of visitEventHandler(), stepping up the hierarchy until the end is reached. The trade-off is that the type of the map becomes public knowledge, rather than merely a private implementation detail of EventBus. Probably a fair trade.
#include <iostream>
#include <typeindex>
#include <vector>
#include <map>
class IEvent;
/* ** Event handler ** */
class BaseEventHandler {
public:
virtual void on(IEvent &) = 0;
};
template<typename Event>
class IEventHandler : public BaseEventHandler {
public:
void on(IEvent &) override {
std::cout << "handle " << typeid(Event).name() << std::endl;
}
};
using HandlerMap = std::map<std::type_index, std::vector<BaseEventHandler *>>;
/* ** Event ** */
class IEvent {
public:
// This is not an actual event type, so there are no handlers to visit.
virtual void visitEventHandlers(HandlerMap &) = 0;
};
// Need a definition for derived classes to call:
void IEvent::visitEventHandlers(HandlerMap &) {}
template<class Base>
class EventFrom : public Base {
public:
void visitEventHandlers(HandlerMap & handlers) override
{
// Visit the handlers for this specific event type.
for (BaseEventHandler *handler : handlers[typeid(EventFrom)])
handler->on(*this);
// Visit the handlers for the parent event type.
Base::visitEventHandlers(handlers);
}
};
using EventA = EventFrom<IEvent>;
using EventB = EventFrom<EventA>;
using EventC = EventFrom<EventB>;
using EventD = EventFrom<EventC>;
/* ** Event Bus ** */
class EventBus {
public:
void fire(IEvent *event) {
event->visitEventHandlers(m_handlers);
}
template<typename T>
void hook(IEventHandler<T> *handler) {
m_handlers[typeid(T)].push_back(handler);
}
protected:
HandlerMap m_handlers{};
};
int main() {
EventBus eb{};
IEventHandler<EventD> ehd{};
IEventHandler<EventC> ehc{};
IEventHandler<EventA> eha{};
eb.hook(&ehd);
eb.hook(&ehc);
eb.hook(&eha);
EventD eD{};
EventB eB{};
std::cout << "Firing event D.\n";
eb.fire(&eD); // need to stdout handle EventD handle EventC handle EventA
std::cout << "\nFiring event B.\n";
eb.fire(&eB); // need to stdout handle EventA
return 0;
}
Some things to note about this approach:
There is quite a bit of complexity used to make sure all event handlers for the most derived class are fired before any handlers for less derived classes. If this is not important, see my other answer.
There are still some issues with this code, but I am willing to chalk them up to being artifacts arising from the need to minimize the example.
There are no macros! (Macros are a red flag, indicating a likely design flaw.)
I would change the signature of hook() to void hook(BaseEventHandler *handler). While this means changes like eb.hook(&ehd) to eb.hook<EventD>(&ehd), it gives more freedom in defining your event handlers (no need for the IEventHandler template). Probably a good trade.