is it possible to get a unique key for a (instance, method) pair?

Hi,

1) Problem in example:
- - -
In the example I'm trying to store a (instance, method) pair
as key in a map, but I'm failing because of a comparison "<"
in the "std::pair"! (code after dashed line in example)

2) Why do I want have this key? .....
- - -
In a subject/observer context I would've to implement an own observer
deriving from an observer interface implementing some methods checking
for that subject initiating the last update delegating into methods
doing the right job. Therefor I've developed a "subject-command-router"
routing a notification of a subject directly to that method handling
the notification (I don't need to derive)!

3) Problem:
- - -
I'm trying to avoid attaching twice the same (instance,method) pair to
the same subject wrapped by different command objects (Wrapper0 in
given example). Therefore I tried to use a map - see 1) and see
example!

Could some help me, please?

best regards,
Thomas

  "example"
======================================
#include <assert.h>
#include <iostream>
#include <map>

class X
{
     public:
         void test1() {std::cout << "X::test1" << std::endl;}
         void test2() {std::cout << "X::test2" << std::endl;}
};

class WrapperBase
{
     public:
         WrapperBase() {}
         virtual ~WrapperBase() {}
         virtual void execute() = 0;
         virtual bool isEqual(const WrapperBase* another) const = 0;
};

typedef std::auto_ptr<WrapperBase> Wrapper;

template <class TInstance, class TMethod>
class WrapperData : public WrapperBase
{
     public:
         WrapperData(TInstance instance, TMethod method)
             : WrapperBase()
             , _instance(instance)
             , _method(method) {}

         virtual ~WrapperData(){}

         virtual bool isEqual(const WrapperBase* another) const
         {
             WrapperData<TInstance, TMethod>* anotherWrapper
                 = (WrapperData<TInstance, TMethod>*)another;

             return anotherWrapper->_instance == _instance
                 && anotherWrapper->_method == _method;
         }
     protected:
         TInstance _instance;
         TMethod _method;
};

template <class TInstance, class TMethod>
class Wrapper0 : public WrapperData<TInstance, TMethod>
{
     public:
         Wrapper0(TInstance instance, TMethod method)
             : WrapperData<TInstance, TMethod>(instance, method) {}

         virtual void execute()
         {
             (this->_instance->*this->_method)();
         }//execute
};//class Wrapper0

template <class TInstance, class TMethod>
Wrapper make_wrapper(TInstance instance, TMethod method)
{
     return Wrapper(new Wrapper0<TInstance, TMethod>(instance, method));
}

int main()
{
     X x1;
     X x2;

     Wrapper meth1 = make_wrapper(&x1, &X::test1);
     meth1->execute();

     Wrapper meth2 = make_wrapper(&x1, &X::test2);
     meth2->execute();

     Wrapper meth3 = make_wrapper(&x2, &X::test1);

     assert( meth1->isEqual(meth3.get()));
     assert(!meth1->isEqual(meth2.get()));
     // --- --- --- --- --- --- --- --- --- --- --- --- --- ---
     typedef void (X::*SIMPLE_METHOD)();
     typedef std::pair <X*, SIMPLE_METHOD> KEY_METHOD;

     KEY_METHOD key1 = std::make_pair(&x1, &X::test1);

     typedef std::map<KEY_METHOD, WrapperBase*> METHOD_MAP;
     METHOD_MAP methods;

     // ...fine (so far)
     // now: (the problem)
     methods.insert(std::make_pair(key1, meth1.get()));
     return 0;
}

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]