#include <boost/shared_ptr.hpp>
#include <map>

// helper struct to allow partial specialization for Event.
template<typename Event, typename Id = char const*>
struct handler_id_for_event;

// Event A
struct event_a_handler_base;
struct event_a
{
    typedef event_a_handler_base handler_type;
};

// Event A handler
struct event_a_handler_base
{
    typedef event_a event_type;
    virtual ~event_a_handler_base() {}
    virtual void handle(event_a& e) = 0;
};

template<typename Id = char const*>
struct event_a_handler : public event_a_handler_base
{
    static Id id();
};

template<>
char const* event_a_handler<char const*>::id()
{
    return "event_a_handler";
}

template<typename Id>
struct handler_id_for_event<event_a,Id>
{
    // Implicit conversion to Id.
    operator Id()
    {
        return event_a_handler<Id>::id();
    }
};

// Event B
struct event_b_handler_base;
struct event_b
{
    typedef event_b_handler_base handler_type;
};

// Event B handler
struct event_b_handler_base
{
    typedef event_b event_type;
    virtual ~event_b_handler_base() {}
    virtual void handle(event_b& e) = 0;
};

template<typename Id = char const*>
struct event_b_handler : public event_b_handler_base
{
    static Id id();
};

template<typename Id>
Id event_b_handler<Id>::id()
{
    return "event_b_handler";
}

template<typename Id>
struct handler_id_for_event<event_b,Id>
{
    // Implicit conversion to Id.
    operator Id()
    {
        return event_b_handler<Id>::id();
    }
};

// Dispatcher.
template<typename Id = char const*>
class event_dispatch_table
{
public:
    // Handler is required to implement function Id Handler::id().
    template<typename Handler>
    void insert(boost::shared_ptr<Handler> handler)
    {
        assert(m_handlers.find(Handler::id()) == m_handlers.end());
        m_handlers[Handler::id()] = handler;
    }

    // Event is required to provide Event::handler_type().
    // Also specialization for struct handler_id_for_event<Event> is
    // required.
    template<typename Event>
    void dispatch(Event& e)
    {
        Event::handler_type* handler
            = static_cast<Event::handler_type*>(handler_for_event<Event>());
        handler->handle(e);
    }

private:
    template<typename Event>
    void* handler_for_event()
    {
        Id id = handler_id_for_event<Event>();
        assert(m_handlers.find(id) != m_handlers.end());
        assert(m_handlers[id]);
        return m_handlers[id].get();
    }

private:
    std::map<Id,boost::shared_ptr<void> > m_handlers;
};

namespace {
    struct simple_a_handler : public event_a_handler<>
    {
        void handle(event_a&) {}
    };
    struct simple_b_handler : public event_b_handler<>
    {
        void handle(event_b&) {}
    };
}

int main()
{
    event_dispatch_table<> table;
    table.insert(
        boost::shared_ptr<event_a_handler<> >(new simple_a_handler));
    table.insert(
        boost::shared_ptr<event_b_handler<> >(new simple_b_handler));

    event_a a;
    event_b b;
    table.dispatch(a);
    table.dispatch(b);

    return 0;
}

// This is a helper class to abstract the concept of Delegate as a function pointer.// T = type of arg passed to the delegate methodtemplate <class T> class DelegateBase : public Object{public:    virtual void Invoke(void * p_sender, T p_event_args) = 0;};            // This class represents a concrete function pointer which can be an instance method or static method.// CLASS = type whose member method we are going to wrap in this Delegate object.// T = type of arg passed to the delegate methodtemplate <class CLASS, class T> class Delegate : public DelegateBase<T>{public:    typedef void (CLASS::*Method)(void*, T);    typedef void (*StaticMethod)(void*, T);    private:    CLASS * instance;               // This is the instance on which the delegate method will be called, or NULL when delegate represents a static method.    Method method;                  // The delegate either holds a pointer to a class member method,    StaticMethod static_method;     // or to a static method.    public:    // Initializes Delegate as pointer to static or global method    inline Delegate(StaticMethod p_method)        :instance(NULL), static_method(p_method)    { }        // Initializes Delegate as pointer to class member instance method    inline Delegate(CLASS * p_instance, Method p_method)        :instance(p_instance), method(p_method)    {        if (p_instance == NULL)            throw InvalidArgumentException();    }        // Calls the function pointer stored in the Delegate object.    // p_sender = optional, usually pointer to object that raised the event    // p_event_args = arguments passed to event handler, are defined by the type of the event    inline void Invoke(void * p_sender, T p_event_args)    {        if (instance)            // the delegate represents an instance method (requires 'this' pointer)            return (instance->*method)(p_sender, p_event_args);        else            // the delegate represents a static method            return (*static_method)(p_sender, p_event_args);    }};            // The event class holds an array of Delegate objects which get invoked when the event is raised.// T = type of arg passed to the delegate method// Only delegates with the same T as the event's can be assigned to the event. template <class T> class Event{private:    Array< DelegateBase<T> * > delegates; // stores pointers to delegate objects    public:    inline Event()    { }    // Raises the event - invokes all assigned delegates    inline void Raise(void * p_sender, T p_event_args)    {        for (int i = 0; i < delegates.Count(); ++i)            delegates->Invoke(p_sender, p_event_args);    }        // Adds a delegate to be invoked with the event.    inline Event & operator += (DelegateBase<T> * p_delegate)    {        delegates.Add(p_delegate);        return * this;    }        inline Event & operator -= (DelegateBase<T> * p_delegate)    {        delegates.Remove(p_delegate);        return * this;    }};

// Class that declares and produces some events.class Button{public:    struct ClickEventArgs // this is just to demonstrate event specialization by arg type    {        int x, y;    };        Event<ClickEventArgs> Clicked;  // this event passes the mouse position to its delegates    Event<int> KeyPressed;          // this event passes the key code to its delegates        void ProcessInput()    {        ClickEventArgs mouse_pos;        int key_code;        // read input from keyboard, mouse, process it        // ...        Clicked.Raise(this, mouse_pos);     // at some point Clicked event is raised to request button click processing        // ...        KeyPressed.Raise(this, key_code);   // at another point KeyPressed event is raised to request processing of the pressed key    }};// Class that consumes some events.class MyApplication{    Button *btn;        void Main()    {        // initialize GUI        btn = new Button();        // wire up event processing        btn->Clicked += new Delegate<MyApplication,ClickEventArgs>(this, &MyApplication::handle_btn_Clicked);        // note we just ignore the other event (no interest in key events in this case)    }        void handle_Clicked(void * p_sender, ClickEventArgs p_args)    {        // Handle button click...        // Now the handler has access to the button (event originator) via p_sender        // and to custom additional arguments via p_args.        printf("Button (%p) was clicked: x = %d, y = %d", p_sender, p_args.x, p_args.y);    }}

class button_clicked_event{    // basically your event args};template<typename Event>class event_signal{public:    void insert_listener(event_signal_listener<Event>&);    void erase_listener(event_signal_listener<Event>&);    void raise(void * p_sender, Event const& e);};