Question

Here is my situation:

I have an event driven system, where all my handlers are derived from IHandler class, and implement an onEvent(const Event &event) method. Now, Event is a base class for all events and contains only the enumerated event type. All actual events are derived from it, including the EventKey event, which has 2 fields: (uchar) keyCode and (bool) isDown.

Here’s the interesting part: I generate an EventKey event using the following syntax:

Event evt = EventKey(15, true);

and I ship it to the handlers:

EventDispatch::sendEvent(evt); // void EventDispatch::sendEvent(const Event &event);

(EventDispatch contains a linked list of IHandlers and calls their onEvent(const Event &event) method with the parameter containing the sent event.

Now the actual question:

Say I want my handlers to poll the events in a queue of type Event, how do I do that?

• Dynamic pointers with reference counting sound like too big of a solution.

• Making copies is more difficult than it sounds, since I’m only receiving a reference to a base type, therefore each time I would need to check the type of event, upcast to EventKey and then make a copy to store in a queue. Sounds like the only solution – but is unpleasant since I would need to know every single type of event and would have to check that for every event received – sounds like a bad plan.

• I could allocate the events dynamically and then send around pointers to those events, enqueue them in the array if wanted – but other than having reference counting – how would I be able to keep track of that memory? Do you know any way to implement a very light reference counter that wouldn’t interfere with the user?

What do you think would be a good solution to this design?

Answer 1

Opinion: choose the reference counting option. Use boost::shareed_ptr, and boost::dynamic_pointer_cast to determine actual type.