Hello Everyone,
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?
x Dynamic pointers with reference counting sound like too big of a solution.
x 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.
x 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?
I thank everyone in advance for your time.
Sincerely,
Kaa
