// описываем класс сообщения
struct my_msg : msg<my_msg>
{
    int data;
    my_msg(int data) : data(data) {}
};

// описываем класс получателя
class my_agent : public agent<my_agent>
{
public:
    my_agent(int data) : data(data) {}
    void on_event(event<my_msg> ev)
    {
        std::cout << "on_event: my_agent::data=" << data << ", my_msg::data=" << ev.msg->data << std::endl;
    }
private:
    int data;
};

// собственно всё, дальше можем отправлять полиморфные сообщения полиморфному получателю
// т.е. ни тип сообщения, ни тип получателя при отправке уже не нужны
int main()
{
    my_agent d (57);
    my_msg m (113);

    agent_base* b = &d;
    msg_base* mb = &m;
    b->send(*mb);
}

std::map<int, std::map<int, void(*)(void*, void const*)> > handlers;

struct msg_base
{
    virtual int get_id() const = 0;

protected:
    static int id_seq_;
};

struct agent_base
{
    virtual int get_id() const = 0;

    void send(msg_base const& m)
    {
        handlers[get_id()][m.get_id()](this, &m);
    }

protected:
    static int id_seq_;
};

template<typename derived_t>
class agent : public agent_base
{
protected:
    template<typename msg_t>
    struct event : class_initializer<event<msg_t> >
    {
        msg_t const* msg;
        agent_base* sender;

    private:
        friend class class_initializer<event<msg_t> >;
        static void static_ctor()
        {
            handlers[derived_t::static_id()][msg_t::static_id()] = &agent::thunk<msg_t>;
        }
    };

    template<typename msg_t>
    static void thunk(void* d, void const* m)
    {
        event<msg_t> ev;
        ev.msg = static_cast<msg_t const*>(static_cast<msg_base const*>(m));
        ev.sender = 0; // просто для примера
        static_cast<derived_t*>(static_cast<agent_base*>(d))->on_event(ev);
    }

    static int id_;

    virtual int get_id() const
    {
        return static_id();
    }

public:
    static int static_id()
    {
        if (id_ == 0)
            id_ = ++agent_base::id_seq_;
        return id_;
    }
};

template<typename derived_t>
class msg : public msg_base
{
private:
    static int id_;

    virtual int get_id() const
    {
        return static_id();
    }

public:
    static int static_id()
    {
        if (id_ == 0)
            id_ = ++msg_base::id_seq_;
        return id_;
    }
};

// определения статических членов (в порядке появления):
int msg_base::id_seq_;
int agent_base::id_seq_;
template<typename derived_t> int agent<derived_t>::id_;
template<typename derived_t> int msg<derived_t>::id_;

R>>    template<typename msg_t>
R>>    static void thunk(void* d, void const* m)
R>>    {
R>>        event<msg_t> ev;
R>>        ev.msg = static_cast<msg_t const*>(static_cast<msg_base const*>(m));
R>>        ev.sender = 0; // просто для примера
R>>        static_cast<derived_t*>(static_cast<agent_base*>(d))->on_event(ev);
R>>    }
R>>

class my_agent : agent<my_agent>
{
  void on_event(event<my_msg, state_start> ev)
  {
  }
  void on_event(event<my_msg, state_error> ev)
  {
  }
};

class my_agent : agent<my_agent>
{
  MSG_MAP(
    (state_init,
      (my_msg1, on_request)
      (my_msg2, on_error)
    )
    (state_error,
      (my_msg1, on_error)
      (my_msg2, on_error)
    )
  );

  void on_request(event<my_msg1> ev)
  {
  }
  void on_error(event<my_msg1> ev)
  {
  }
  void on_error(event<my_msg2> ev)
  {
  }
};

struct receiver_desc_t
{
  int min_id;
  int max_id;
  handler_t* array;

  handler_t* get_handler(int msg_id)
  {
    if (msg_id >= min_id && msg_id < max_id)
      return array[msg_id - min_id];
    else
      return 0;     
  }
};

// базовый тип сообщения
class msg
{
    template<typename> friend class msgqueue;
    unsigned int id;
};
// сочередь сообщений
template<typename impl_type>
class msgqueue
{
public:
    template<typename msg_type>
    void post(msg_type* m)
    {
        msg* b = static_cast<msg*>(m);
        b->id = handler<msg_type>::id;
        // здесь помещаем в очередь, потом эту очередь откуда то разгребаем
        // но это пример, так что сразу синхронно вызовем dispatch
        dispatch_message(b);    
    }
private:
    void post(msg*); // закрываем возможность отправки сообщений через базовый тип
    // таблица обработчиков сообщений, генерируется при инициализации статики
    static std::vector<void(*)(void*, void*)> handlers;
    // собственно handler
    template<typename msg_type>
    struct handler : static_initializer<handler<msg_type> >
    {
        static unsigned int id;
        // регистрируем обработчик в таблице
        static void static_ctor()
        {
            id = (unsigned int) handlers.size();
            handlers.push_back(handle);            
        }
        // функция обработки сообщения
        static void handle(void* q, void* m) 
        {
            static_cast<impl_type*>(q)->on_msg(static_cast<msg_type*>(m));
            delete static_cast<msg_type*>(m); // и виртуальный деструктор не требуется
        }
    };
    // метод сопоставления сообщению обработчика
    void dispatch_message(msg* m)
    {
        handlers[m->id](this, m);
    }
};
// инициализируем статику
template<typename impl_type> std::vector<void(*)(void*, void*)> msgqueue<impl_type>::handlers;
template<typename impl_type> template<typename msg_type> unsigned int msgqueue<impl_type>::handler<msg_type>::id = 0;

struct my_msg : msg
{
    my_msg(int i) : i(i) {}
    int i;
};
struct my_queue : msgqueue<my_queue>
{
    void on_msg(my_msg* m)
    {
        printf("%d\n", m->i);
    }
};

int main() 
{
    my_queue msgq;
    // такая запись заставляет инстанцировать метод my_queue::on_message(my_msg*)
    msgq.post(new my_msg(42)); 
    // особенность подхода: нельзя делать post через базу
    // msgq.post(static_cast<msg*>(new my_msg(42))); // ошибка - private метод
}

// базовый тип сообщения
class msg
{
    template<typename> friend class msgqueue;
    void (* handle)(void*, void*);
    unsigned int id;
};
// сочередь сообщений
template<typename impl_type>
class msgqueue
{
public:
    template<typename msg_type>
    void post(msg_type* m)
    {
        m->handle = handle<msg_type>;
        // здесь помещаем в очередь, потом эту очередь откуда то разгребаем
        // но это пример, так что сразу вызовем dispatch
        dispatch_message(m);    
    }
private:
    void post(msg*); // закрываем возможность отправки сообщений через базовый тип
    // функция обработки сообщения
    template<typename msg_type>
    static void handle(void* q, void* m) 
    {
        static_cast<impl_type*>(q)->on_msg(static_cast<msg_type*>(m));
        delete static_cast<msg_type*>(m); // и виртуальный деструктор не требуется
    }
    // метод обработки сообщения
    void dispatch_message(msg* m) { m->handle(this, m); }
};