Observer pattern with type information (C++)

Question

i'm trying to implement a custom version of an Observer pattern in c++.

These are my classes (just interface):

class Observer{
public:
    void observe(std::string behaviour, Observable * observable);
    void stopObserving(std::string behaviour, Observable * observable);
    virtual void notified(std::string behaviour, Observable * observed);
// ...
};

class Observable{
public:
    void notifyBehaviour(std::string behaviour);
    // ...
};

And can be used like this:

class A : public Observer{
public:
    void notified(std::string behaviour, Observable * observed){
        if (behaviour == "jumping"){
            // ...
        }
    }
};

class B : public Observable{
public:
    void jump(){
        // ...
        notifyBehaviour("jumping");
    }
};

int main(){
    A a;
    B b;
    a.observe("jumping", &b);
    b.jump();
    // ...
}

Each class implementing Observer can register itself as observing an Observable with a behaviour.

The Observable can notify its actions with "notifyBehaviour" to everyone interested.

Each Observer listening will be notified via its method "notified".

The above works perfectly. Anyway in the example above:

void notified(std::string behaviour, Observable * observed){
    if (behaviour == "jumping"){
    // ...
}

i'd like to use the Observable * i'm passing to do something on the notifying object. Unfortunately i'll have to do something like this:

void notified(std::string behaviour, Observable * observed){
    if (behaviour == "jumping"){
        auto pointer = dynamic_cast<B *>(observed);
        if (pointer)
            pointer->doSomethingElse();
    }
}

That's ugly and will probably create problems. For example observing two different jumping entities will need multiple castings waiting for the right one.

My question is: is it possible to pass some RTTI or call an overloaded function or a template having already the right object type? I'd like to have:

class A : public Observer{
public:
    void notified(std::string behaviour, B * observed){
        if (behaviour == "jumping"){
            observed->doSomethingBlike();
            // observed if of type B !
        }
    }
    void notified(std::string behaviour, C * observed){
        if (behaviour == "jumping"){
            observed->doSomethingClike();
            // observed if of type C !
        }
    }
};

so i just need to implement the various object types i'd like to listen.

I've tried with inheritance, templates, boost::any but still without luck.

Thanks for ideas.

Answer 1

Declare a pure virtual method in the Observed class. Or just an empty virtual function so there's no need to override.

class Observed {
public:
    virtual ~Observed();
    Observed();
    virtual void DoSomethingElse() {} // OR
    //void DoSomethingElse() = NULL;

    // rest of class

};

Answer 2

I have done this recently in a couple of projects. The basic idea:

I created a base class (Notified) that has a virtual method for each interface you wish to receive:

class Notified
{
public:
   virtual bool Notify(NOTIFIED_EVENT_TYPE_T eventType, uint32 value)
   { return false; };
   virtual bool Notify(NOTIFIED_EVENT_TYPE_T eventType, ITEM_ID_T value)
   { return false; };
   virtual bool Notify(NOTIFIED_EVENT_TYPE_T eventType, const string& value)
   { return false; };
   virtual ~Notified(); 
};

I created a singleton to act as a central point to hold which things you want to send messages to (derived from Notified) and methods to call them:

    class Notifier : public SingletonDynamic<Notifier>
     {

         private:
            ... detail omitted...

         public:

            virtual void Reset();
            virtual bool Init() { Reset(); return true; }
            virtual void Shutdown() { Reset(); }

            void Attach(Notified* observer, NOTIFIED_EVENT_TYPE_T eventType);
            // Detach for a specific event
            void Detach(Notified* observer, NOTIFIED_EVENT_TYPE_T eventType);
            // Detach for ALL events
            void Detach(Notified* observer);

            // This template function (defined in the header file) allows you to
            // add interfaces to Notified easily and call them as needed.  Variants
            // will be generated at compile time by this template.

            template <typename T>
            bool Notify(NOTIFIED_EVENT_TYPE_T eventType, const T& value)
            {
              ...detail omitted
            }



            /* Used for CPPUnit.  Could create a Mock...maybe...but this seems
             * like it will get the job done with minimal fuss.  For now.
             */
            // Return all events that this object is registered for.
            vector<NOTIFIED_EVENT_TYPE_T> GetEvents(Notified* observer);
            // Return all objects registered for this event.
            vector<Notified*> GetNotified(NOTIFIED_EVENT_TYPE_T event);
         };

It is tempting to try and make a template method for the Notified class:

template <typename T>
virtual bool Notify(NOTIFIED_EVENT_TYPE_T eventType, const T& value)

But you cannot because it needs to be virtual so you can have your derived class handle it. I thought about digging deeper into doing it as a template (meta template stuff), but I think that would confuse an otherwise generally simple to use and understandable design.

The main point of this design is:
1. You get complete type safety calling your Notified derived classes, checked directly through the compile process. 2. If you don't implement a handler for your function, you can have the Notifier class throw an exception when you return false. 3. Writing code for each handler in a Notified derived class is trivial:

   class MyNotified : public Notified
    {
        virtual bool Notified(NOTIFIED_EVENT_T evt, uint32 value)
        {
          bool result = true;
          switch(evt)
          {
          case EVT_1:
              ...do something...
              break;
          default:
              result = false;
          }
          return result;
        }
   };

I have examples of this in (in various stages of life) in posts found here.

Was this helpful?