Callback system for events in a window

I do NOT recommend doing this

I would do this somehow different. I'm not sure why you need an id at all. A listener/receiver is interested in a specific type of event, isn't it? If you want to follow your "poll and get" flow, all you have to do is to store your events somehow.

If you're using c++11 (and I guess you are), things are easier, variadic template arguments are so good. This whole thing could be done totally different, but I'm trying to follow and adjust your code. So here comes I've came up with:

I dropped the whole id thing and I'm using the event type only. I created a base EventDataBase class. This can be used to get the real data from the event data object.

class EventDataBase
{
public:
    const sf::Event::EventType event;

    EventDataBase(sf::Event::EventType event)
        : event(event)
    { }
    virtual ~EventDataBase() { }

    template <class T>
    T* getData()
    {
        return static_cast<T*>(getDataPtr());
    }

protected:
    virtual void* getDataPtr() = 0;
};

Then a simple template class is created which holds the actual data:

template <class T, typename... Args>
class EventData : public EventDataBase
{
public:
    EventData(sf::Event::EventType event, Args... args)
        : EventDataBase(event),
          data(args...)
    { }

private:
    T data;

    void* getDataPtr() override { return &data; }
};

With the variadic template args the constructor of your actual data can have any parameters (but that must match!). Another solution would be to pass an existing T object to the EventData class but that means the T must be copy-constructable:

template <class T>
class EventData : public EventDataBase
{
public:
    EventData(sf::Event::EventType event, const T& data)
        : EventDataBase(event),
          data(data)
    { }

private:
    T data;

    void* getDataPtr() override { return &data; }
};

Then you can use typedefs if you wish. I'm using the variadic-template-args solution from now, but you can adjust your code.

typedef EventData<sf::Event::SimpleEvent> SimpleEventData;
// downside is that the Args must match the parameters of the KeyEvent's constructor
typedef EventData<sf::Event::KeyEvent, int> KeyEventData;

I'm not sure if you have only one EventManager or not but I guess you have only one and you call the pollEvent function in the application's main loop. I ignored the subscribe functionality, but that can be added easily.

class EventManager
{
public:
    // called in the application's main loop
    void pollEvent(const sf::Event& event)
    {
        // if you want to check if anyone is interested in this event, do it here
        // ...

        EventDataBase* eventData = nullptr;

        switch (event.type)
        {
        case sf::Event::Simple:
            eventData = new SimpleEventData(event.type);
            break;

        case sf::Event::KeyPressed:
        case sf::Event::KeyReleased:
            eventData = new KeyEventData(event.type, 10 /* key code */);
            break;

        default:
            break;
        }

        if (eventData)
            polledEvents.push_back(eventData);
    }

    template <typename T>
    T* hasEvent(sf::Event::EventType event)
    {
        auto it = std::find_if(polledEvents.begin(), polledEvents.end(),
                               [event](EventDataBase* data) { return data->event == event; });

        if (it == polledEvents.end())
            return nullptr;

        return (*it)->getData<T>();
    }

    // TODO: clearEvents() function is basically the same
    // you have to delete the EventDataBase objects
    // and clear the polledEvents vector

private:
    // you can use a map<EventType, EventDataBase*>
    // if only one event is allowed per type
    // but in a real application that's not true (eg. KeyPressed)
    typedef std::vector<EventDataBase*> Events;

    Events polledEvents;
};

And the usage:

EventManager mgr;
mgr.pollEvent(sf::Event(sf::Event::Simple));
mgr.pollEvent(sf::Event(sf::Event::KeyPressed));
mgr.pollEvent(sf::Event(sf::Event::KeyReleased));

sf::Event::SimpleEvent* simple = mgr.hasEvent<sf::Event::SimpleEvent>(sf::Event::Simple);
sf::Event::KeyEvent* keyPressed = mgr.hasEvent<sf::Event::KeyEvent>(sf::Event::KeyPressed);
sf::Event::KeyEvent* keyReleased = mgr.hasEvent<sf::Event::KeyEvent>(sf::Event::KeyReleased);

Questions:

• What happens when you have multiple event with the same type (eg. KeyPressed)? (You can modify the hasEvent function to fill a vector instead of return with the first matched element)
• What happens when you get an event with a wrong type? (eg. hasEvent<Event::KeyEvent>(EventType::Simple))
• Do you really want to allow the hasEvent caller to modify the event data? If not, you should return (or fill) const T* instead of T*
• What happens if the hasEvent caller delete the returned object? That's not even heap allocated! Instant crash I guess...

So I'm not sure if this is the best way you can do it. The hasEvent function is dangerous. What if I try to get a sf::Event::KeyEvent with a sf::Event::Simple type? The data is simply "converted" (casted) to the desired type. And eg. if I try to modify the data... You can imagine. Consider the following example.

// invalid cast, but it's done
sf::Event::KeyEvent* keyPressed = mgr.hasEvent<sf::Event::KeyEvent>(sf::Event::Simple);
// modify the data
keyPressed->key = 0;

// ... random crash
// because the `keyPressed` points to a bigger memory area than it should
// sizeof(KeyEvent) > sizeof(SimpleEvent) !!

A better approach

[...] would be message-based. I mean real message based. A class could subscribe to the manager with its object pointer and a function. That function would be called when an event occurs. So your code should not have to call "hasEvent" everywhere but instead the registered function would be called automatically. Something like this (pseudo-code):

// in the manager

// define the events
Event<int> onKeyPressed;
Event<int> onKeyReleased;

// when an application creates an event
switch (event.type)
{
case EventType::KeyPressed:
    onKeyPressed(event.key);
    break;

    // ...
}

// your listener/receiver code:

// define the handler function
void callThisOnKeyPressed(int key)
{
    // handle key pressed event
}

// register to event
manager.onKeyPressed.subscribe(this, &MyClassName::callThisOnKeyPressed);

In c++11 this can be implemented easily with some template magic. :)

Edit

I totally forget to mention the object pooling. Constantly calling new and delete is not too memory-friendly. You can use a custom memory manager (placement new) to solve this issue.

Edit 2

You can actually check if the event type is valid for the specific event data with a template "checking" function, something like this:

template <typename T>
bool isTypeAllowed(sf::Event::EventType type);

template <>
bool isTypeAllowed<sf::Event::KeyEvent>(sf::Event::EventType type)
{
    return (type == sf::Event::KeyPressed || type == sf::Event::KeyReleased);
}

You can use this function to check if the specified EventType is valid for the T event data type. You can do this check in the hasEvent function:

template <typename T>
T* hasEvent(sf::Event::EventType event)
{
    if (!isTypeAllowed<T>(event))
        return nullptr;

    auto it = std::find_if(polledEvents.begin(), polledEvents.end(),
                           [event](EventDataBase* data) { return data->event == event; });

    if (it == polledEvents.end())
        return nullptr;

    return (*it)->getData<T>();
}

// or the collection variant:

template <typename T>
bool hasEvent(sf::Event::EventType event, std::vector<T*>& result)
{
    result.clear();

    if (!isTypeAllowed<T>(event))
        return false;

    for (auto& e : polledEvents)
    {
        if (e->event == event)
            result.push_back(e->getData<T>());
    }

    return !result.empty();
}