#include <iostream>
#include <list>
#include <functional>
#include <algorithm>
#include <typeinfo>

class Event
{
  public:
    int n;
    static int serial;
    Event() { n = serial++; }
    virtual ~Event() {}
};

int Event::serial = 0;

class Event1 : public Event {};

class Event2 : public Event {};

class Event11 : public Event1 {};
class Event12 : public Event1 {};

class Event21 : public Event2 {};
class Event22 : public Event2 {};

class EventHandlerBase
{
  public:
    virtual void handleEvent(Event*) = 0;
    virtual ~EventHandlerBase() {}
};

template <class Ev>
class EventHandler : public EventHandlerBase
{
    void handleEvent(Event* event)
    {
        Ev* derivedEvent = dynamic_cast<Ev*>(event);
        if (derivedEvent)
        {
            handleEvent(derivedEvent);
        }
    }

    virtual void handleEvent(Ev*) = 0;
};

class H1 : public EventHandler<Event1>
{
    void handleEvent(Event1* ev)
    {
        std::cout << "Event1 handled : " << typeid(*ev).name()
          << "," << ev-> n << std::endl;
    }
};

class H12 : public EventHandler<Event12>
{
    void handleEvent(Event12* ev)
    {
        std::cout << "Event12 handled : " << typeid(*ev).name()
          << "," << ev-> n << std::endl;
    }
};

class H21 : public EventHandler<Event21>
{
    void handleEvent(Event21* ev)
    {
        std::cout << "Event21 handled : " << typeid(*ev).name()
          << "," << ev-> n << std::endl;
    }
};

class EventDispatcher
{
    std::list<EventHandlerBase*> handlers;
  public:
    void addHandler (EventHandlerBase* eh)
    {
        handlers.push_back(eh);
    }
    void dispatch (Event* ev)
    {
        std::for_each(handlers.begin(), handlers.end(),
                      std::bind2nd(std::mem_fun(&EventHandlerBase::handleEvent), ev));
    }
};

int main ()
{
    EventDispatcher ed;

    ed.addHandler(new H1);
    ed.addHandler(new H12);
    ed.addHandler(new H21);

    std::cout << "go Event1 ---" << std::endl;
    ed.dispatch(new Event1);
    std::cout << "go Event11 ---" << std::endl;
    ed.dispatch(new Event11);
    std::cout << "go Event12 ---" << std::endl;
    ed.dispatch(new Event12);
    std::cout << "go Event21 ---" << std::endl;
    ed.dispatch(new Event21);
    std::cout << "go Event22 ---" << std::endl;
    ed.dispatch(new Event22);
}