Re: Replacement for "switch" that can use non-const values?

[long post warning - lots of (bad?) code ahead...]

On Aug 13, 12:17 am, Ian Collins <ian-n...@hotmail.com> wrote:


Ok, so I lied...
I actually do have different classes. Since I'm trying to make this
generic so I can apply the mechanism to various classes. Furthermore,
I'd like something where I can apply the mechanism to a base class,
but also use it in a derived class.

So here's what I came up with:

---------- FILE: dynamicdispatch.h ----------

Link to formatted source code here:
http://ironcreek.net/code/dynamicdispatch.h

#ifndef DYNAMICDISPATCH_H
#define DYNAMICDISPATCH_H

#include <map>

#define REGISTERMSG(msg, class, func) RegisterHandler( msg, new
MsgHandler<class>( this, &class::func ));

class IMsgHandler
{
public:
    virtual unsigned Handle( unsigned, unsigned ) = 0;
};

template <typename T>
class MsgHandler : public IMsgHandler
{
public:
    typedef unsigned (T::*HandlerFunc)( unsigned, unsigned );

    MsgHandler( T* pobj, HandlerFunc handler )
        : obj( pobj )
        , func( handler )
    {
    }

    unsigned Handle( unsigned p1, unsigned p2 )
    {
        return (obj->*func)( p1, p2 );
    }

protected:
    T *obj;
    HandlerFunc func;
};

class DynamicDispatch
{
public:
    ~DynamicDispatch()
    {
        std::map<unsigned, IMsgHandler*>::iterator ii;
        for( ii = func_map.begin(); ii != func_map.end(); ++ii )
            delete ii->second;
    }

    void RegisterHandler( unsigned msg, IMsgHandler *p_handler )
    {
        func_map[ msg ] = p_handler;
    }

    unsigned HandleMessage( unsigned msg, unsigned p1, unsigned p2 )
    {
        std::map<unsigned, IMsgHandler*>::iterator ii =
func_map.find( msg );
        if ( ii != func_map.end() )
            return ii->second->Handle( p1, p2 );
        return 0;
    }

protected:
    std::map<unsigned, IMsgHandler*> func_map;
};

#endif

---------- FILE: funcmap.cpp ----------

Link to formatted source code here:
http://ironcreek.net/code/funcmap.cpp

#include <iostream>
#include "dynamicdispatch.h"

const unsigned FIRST_EVENT = 1000;
const unsigned SECOND_EVENT = 2000;
const unsigned THIRD_EVENT = 3000;

class Dialog : public DynamicDispatch
{
public:
    Dialog()
    {
        REGISTERMSG( THIRD_EVENT, Dialog, MyEvent );
    }

    unsigned MyEvent( unsigned, unsigned )
    {
        std::cout << "Dialog::MyEvent()\n";
        return 0;
    }
};

class MyDlg : public Dialog
{
public:
    MyDlg()
    {
        REGISTERMSG( FIRST_EVENT, MyDlg, Func1 );
        REGISTERMSG( SECOND_EVENT, MyDlg, Func2 );
    }

    unsigned Func1( unsigned p1, unsigned p2 )
    {
        std::cout << "MyDlg::Func1() p1=" << p1 << " p2=" << p2 <<
"\n";
        return 0;
    }

    unsigned Func2( unsigned p1, unsigned p2 )
    {
        std::cout << "MyDlg::Func2() p1=" << p1 << " p2=" << p2 <<
"\n";
        return 0;
    }

    void Test()
    {
        HandleMessage( FIRST_EVENT, 11, 22 );
        HandleMessage( SECOND_EVENT, 11, 22 );
        HandleMessage( THIRD_EVENT, 11, 22 );
    }
};

int main()
{
    MyDlg dlg;
    dlg.Test();
}

Now, I am _reasonably_ happy with that code - except for one thing.
The macro (REGISTERMSG) I use to register the message handlers. But
the alternative syntax that the macro masks, is a bit hard on the eye
if repeated often...

So what do you guys think about this code and are there any
suggestions to make the REGISTERMSG() functionality not a macro, but
still as clean as possible?

Thanks,
   Andre