I’m trying to make a simple GUI system using the same approach. I define class UIControl derived from EventDispatcher and my purpose is to keep all the event handlers as member functions of corresponding classes, like I can do it in ActionScript3. Thus, I redefine eventFunctionPtr as typedef void (UIControl::*eventFunctionPtr)(const Event &) and this causes some problems:

1)To execute the callback, now I need to know the UI control object itself, its member function and an event to pass, so I need to define new CallbackWrapper class to store object and member function.

2)Instantiating CallbackWrapper fails if instead of UIControl instance I use its descendant, for example, Button. In particular, C++ compiler can’t cast void (UIControl::*eventFunctionPtr)(const Event &) to void (Button::*eventFunctionPtr)(const Event &).

3)The problem can be particularly solved if we define CallbackWrapper as a template class, with the type of control as T and its callback type as void (T::*eventFunctionPtr)(const Event &). But in that case we can’t define a map of callbacks as we can use listeners of different type.

Maybe I’m trying to make something strange and more simple solution exists?

void removeEventListener(const std::string &type, function listener){
if(!hasEventListener(type))
return;

std::map<int, std::list > &allFunctions = eventHandlerList[type];
std::map<int, std::list >::iterator it;
it=allFunctions.begin();

while(it != allFunctions.end())
{
it->second.remove(listener);

if (it->second.empty()) { allFunctions.erase(it++); }
else { ++it; }
}

if(allFunctions.empty())
eventHandlerList.erase(type);
}

error: passing ‘const std::list’ as ‘this’ argument of ‘void std::list::remove(const value_type&) [with _Tp = void (*)(const st::event::Event&), _Alloc = std::allocator, std::list::value_type = void (*)(const st::event::Event&)]’ discards qualifiers [-fpermissive]

error: no matching function for call to ‘std::map<int, std::list >::erase(std::map<int, std::list >::const_iterator&)’

for(std::map<int, std::list >::iterator i=allFunctions.begin(); i!=allFunctions.end(); ++i) {
// Saving a branch here: instead of checking if the callback exists let remove() do it for us
i->second.remove(listener);

// Remove object from the map if list gone empty to eliminate false positives
if(i->second.empty())
allFunctions.erase(i);
}

Doesn’t work due to the iterator being lost. Any suggestion?

EventDispatcher::removeEventListener will remove only the function pointer as given, that’s what i->second.remove(listener); is for.

The listeners are kept in a sorted std::map to accommodate the priorities, and all it takes is (reverse) traversal to get the correct order during the dispatch phase.