Implementing Observer pattern when observers wish

Question

Below I have attempted to write a sudo code for the Observer pattern when observers wish to observe different items.

Ignore the syntax errors. I wish to know if this is the correct way to implement this. If not, please suggest better ways.

// Used by the subject for keeping a track of what items the observer wants to observe
typedef struct observerListStruct
{
    bool getTemperatureUpdate;
    bool getHumidityUpdate;
    bool getPressureUpdate;
    observer's-function pointer's address;
};

// Subject's class
class weatherData
{
    public:
        // Observers will call this function to register themselves. The function pointer will point to the function which will get called when updates are available.
        void registerObservers (observer obj, observer's-FunctionPointer)
        {
            // This observer's function returns which items to observe.
            char* f = obj.returnItemsToObserve ();
            if f[0] = `1`
                observerListStruct.getTemperatureUpdate = true;
        }

        void unregisterObservers (observer obj) {}

    private:
        vector <observerListStruct> observerList;
        float temperature;
        float humidity;
        float pressure;

        void notifyObservers ()          {}

        float getTemperature ()          {}
        float getHumidity ()                 {}
        float getPressure ()                 {}
} weatherDataObject;

// Base class for observers containing common functions
class observers
{
    char ItemsToObserve [3] = {1, 2, 3};

    // This observer's function returns which items to observe. Default - return all items
        virtual char* returnItemsToObserve ()
    {
        return ItemsToObserve;
    }
};

class observerDisplayElementCurrentConditions : public observers
{
    char ItemsToObserve [3] = {1, 2};

    char* returnItemsToObserve ()
    {
        return ItemsToObserve;
    }

    // this function will be used as a function pointer for getting updates
    void getUpdatesAndDisplayWeatherData (float, float) {}
};

Answer 1

My two cents...

Classic (Gang of Four) implementation of Observer pattern notifies observer on changes in any property of the subject. In your question you want to register observer to particular properties, not to a subject as a whole. You can move Observer pattern one level down and take properties as concrete subjects and define their observers (per property) but there is one nicer way to solve this problem.

In C# Observer pattern is implemented through events and delegates. Delegates represent event handlers - functions that should be executed when an event is fired. Delegates can be added (registered) or removed(unregistered) from events.

In C++, functors act as delegates - they can store all necessary information to call some global function or class method in a different context. Events are collections of (registered) functors and when event is raised (called) it basically goes through that list and calls all functors (see Publisher::publish method in juanchopanza's solution).

I tried to implement C++ version of events and delegates and use them in modified Observer pattern which could be applied in your case. This is what I came up with:

#include <list>
#include <iostream>
#include <algorithm>

// use base class to resolve the problem of how to put into collection objects of different types
template <typename TPropertyType>
struct PropertyChangedDelegateBase
{
    virtual ~PropertyChangedDelegateBase(){};
    virtual void operator()(const TPropertyType& t) = 0;
};

template <typename THandlerOwner, typename TPropertyType>
struct PropertyChangedDelegate : public PropertyChangedDelegateBase<TPropertyType>
{
    THandlerOwner* pHandlerOwner_;

    typedef void (THandlerOwner::*TPropertyChangeHandler)(const TPropertyType&);
    TPropertyChangeHandler handler_;

public:
    PropertyChangedDelegate(THandlerOwner* pHandlerOwner, TPropertyChangeHandler handler) : 
      pHandlerOwner_(pHandlerOwner), handler_(handler){}

    void operator()(const TPropertyType& t)
    {
        (pHandlerOwner_->*handler_)(t);
    }
};

template<typename TPropertyType>
class PropertyChangedEvent
{
public:
    virtual ~PropertyChangedEvent(){};

    void add(PropertyChangedDelegateBase<TPropertyType>* const d)
    {
        std::list<PropertyChangedDelegateBase<TPropertyType>* const>::const_iterator it = std::find(observers_.begin(), observers_.end(), d);
        if(it != observers_.end())
            throw std::runtime_error("Observer already registered");

        observers_.push_back(d);
    }


    void remove(PropertyChangedDelegateBase<TPropertyType>* const d)
    {       
        std::list<PropertyChangedDelegateBase<TPropertyType>* const>::const_iterator it = std::find(observers_.begin(), observers_.end(), d);
        if(it != observers_.end())
            observers_.remove(d);
    }   

    // notify
    void operator()(const TPropertyType& newValue)
    {
        std::list<PropertyChangedDelegateBase<TPropertyType>* const>::const_iterator it = observers_.begin();
        for(; it != observers_.end(); ++it)
        {
            (*it)->operator()(newValue);
        }
    }

protected:
    std::list<PropertyChangedDelegateBase<TPropertyType>* const> observers_;
};

// class that owns concrete subjects
class PropertyOwner1
{
    int property1_;
    float property2_;   
public:
    PropertyChangedEvent<int> property1ChangedEvent;
    PropertyChangedEvent<float> property2ChangedEvent;

    PropertyOwner1() : 
        property1_(0), 
        property2_(0.0f)
    {}  

    int property1() const {return property1_;}
    void property1(int n) 
    {
        if(property1_ != n)
        {
            property1_ = n;
            std::cout << "PropertyOwner1::property1(): property1_ set to " << property1_ << std::endl;
            property1ChangedEvent(property1_);
        }
    }

    float property2() const {return property2_;}
    void property2(float n) 
    {
        if(property2_ != n)
        {
            property2_ = n;
            std::cout << "PropertyOwner1::property2(): property2_ set to " << property2_ << std::endl;
            property2ChangedEvent(property2_);
        }
    }
};

// class that owns concrete subjects
class PropertyOwner2
{
    bool property1_;
    double property2_;  
public:
    PropertyChangedEvent<bool> property1ChangedEvent;
    PropertyChangedEvent<double> property2ChangedEvent;

    PropertyOwner2() : 
        property1_(false), 
        property2_(0.0)
    {}  

    bool property1() const {return property1_;}
    void property1(bool n) 
    {
        if(property1_ != n)
        {
            property1_ = n;
            std::cout << "PropertyOwner2::property1(): property1_ set to " << property1_ << std::endl;
            property1ChangedEvent(property1_);
        }
    }

    double property2() const {return property2_;}
    void property2(double n) 
    {
        if(property2_ != n)
        {
            property2_ = n;
            std::cout << "PropertyOwner2::property2(): property2_ set to " << property2_ << std::endl;
            property2ChangedEvent(property2_);
        }
    }
};

// class that observes changes in property1 of PropertyOwner1 and property1 of PropertyOwner2
struct PropertyObserver1
{   
    void OnPropertyOwner1Property1Changed(const int& newValue)
    {
        std::cout << "\tPropertyObserver1::OnPropertyOwner1Property1Changed(): \n\tnew value is: " << newValue << std::endl;
    }

    void OnPropertyOwner2Property1Changed(const bool& newValue)
    {
        std::cout << "\tPropertyObserver1::OnPropertyOwner2Property1Changed(): \n\tnew value is: " << newValue << std::endl;
    }
};

// class that observes changes in property2 of PropertyOwner1 and property2 of PropertyOwner2
struct PropertyObserver2
{   
    void OnPropertyOwner1Property2Changed(const float& newValue)
    {
        std::cout << "\tPropertyObserver2::OnPropertyOwner1Property2Changed(): \n\tnew value is: " << newValue << std::endl;
    }

    void OnPropertyOwner2Property2Changed(const double& newValue)
    {
        std::cout << "\tPropertyObserver2::OnPropertyOwner2Property2Changed(): \n\tnew value is: " << newValue << std::endl;
    }
};

int main(int argc, char** argv)
{
    PropertyOwner1 propertyOwner1;  
    PropertyOwner2 propertyOwner2;      

    PropertyObserver1 propertyObserver1;
    PropertyObserver2 propertyObserver2;

    // register observers
    PropertyChangedDelegate<PropertyObserver1, int> delegate1(&propertyObserver1, &PropertyObserver1::OnPropertyOwner1Property1Changed);
    propertyOwner1.property1ChangedEvent.add(&delegate1);

    PropertyChangedDelegate<PropertyObserver2, float> delegate2(&propertyObserver2, &PropertyObserver2::OnPropertyOwner1Property2Changed);
    propertyOwner1.property2ChangedEvent.add(&delegate2);

    PropertyChangedDelegate<PropertyObserver1, bool> delegate3(&propertyObserver1, &PropertyObserver1::OnPropertyOwner2Property1Changed);
    propertyOwner2.property1ChangedEvent.add(&delegate3);

    PropertyChangedDelegate<PropertyObserver2, double> delegate4(&propertyObserver2, &PropertyObserver2::OnPropertyOwner2Property2Changed);
    propertyOwner2.property2ChangedEvent.add(&delegate4);

    propertyOwner1.property1(1);
    propertyOwner1.property2(1.2f);

    propertyOwner2.property1(true);
    propertyOwner2.property2(3.4);

    // unregister PropertyObserver1
    propertyOwner1.property1ChangedEvent.remove(&delegate1);
    propertyOwner2.property1ChangedEvent.remove(&delegate3);

    propertyOwner1.property1(2);
    propertyOwner1.property2(4.5f);
}

Output:

    PropertyOwner1::property1(): property1_ set to 1
      PropertyObserver1::OnPropertyOwner1Property1Changed():
      new value is: 1 
    PropertyOwner1::property2(): property2_ set to 1.2
      PropertyObserver2::OnPropertyOwner1Property2Changed():
      new value is: 1.2 
    PropertyOwner2::property1(): property1_ set to 1
      PropertyObserver1::OnPropertyOwner2Property1Changed():
      new value is: 1 
    PropertyOwner2::property2(): property2_ set to 3.4
      PropertyObserver2::OnPropertyOwner2Property2Changed():
      new value is: 3.4 
    PropertyOwner1::property1(): property1_ set to 2 
    PropertyOwner1::property2(): property2_ set to 4.5
      PropertyObserver2::OnPropertyOwner1Property2Changed():
      new value is: 4.5

Each observer is registered with a particular property and when notified, each observer knows exactly who is the owner of the property and what's property's new value.

Answer 2

I write a lot of C++ code and needed to create an Observer for some game components I was working on. I needed something to distribute "start of frame", "user input", etc., as events in the game to interested parties.

I also wanted more granularity in the events that could be handled. I have a lot of little things that go off...I don't need to have the parts that are interested in resetting for the next frame worried about a change in the user input.

I also wanted it to be straight C++, not dependent on the platform or a specific technology (such as boost, Qt, etc.) because I often build and re-use components (and the ideas behind them) across different projects.

Here is the rough sketch of what I came up with as a solution:

1. The Observer is a singleton with keys (enumerated values, not strings; this is a speed tradeoff since the keys are not searched hashed, but it means no easy "string" names and you have to define them ahead of time) for Subjects to register interest in. Because it is a singleton, it always exists.
2. Each subject is derived from a common base class. The base class has an abstract virtual function Notify(...) which must be implemented in derived classes, and a destructor that removes it from the Observer (which it can always reach) when it is deleted.
3. Inside the Observer itself, if Detach(...) is called while a Notify(...) is in progress, any detached Subjects end up on a list.
4. When Notify(...) is called on the Observer, it creates a temporary copy of the Subject list. As it iterates over it, it compare it to the recently detached. If the target is not on it, Notify(...) is called on the target. Otherwise, it is skipped.
5. Notify(...) in the Observer also keeps track of the depth to handle cascading calls (A notifies B, C, D, and the D.Notify(...) triggers a Notify(...) call to E, etc.)

This is what the interface ended up looking like:

/* 
 The Notifier is a singleton implementation of the Subject/Observer design
 pattern.  Any class/instance which wishes to participate as an observer
 of an event can derive from the Notified base class and register itself
 with the Notiifer for enumerated events.

 Notifier derived classes MUST implement the notify function, which has 
 a prototype of:

 void Notify(const NOTIFIED_EVENT_TYPE_T& event)

 This is a data object passed from the Notifier class.  The structure 
 passed has a void* in it.  There is no illusion of type safety here 
 and it is the responsibility of the user to ensure it is cast properly.
 In most cases, it will be "NULL".

 Classes derived from Notified do not need to deregister (though it may 
 be a good idea to do so) as the base class destructor will attempt to
 remove itself from the Notifier system automatically.

 The event type is an enumeration and not a string as it is in many 
 "generic" notification systems.  In practical use, this is for a closed
 application where the messages will be known at compile time.  This allows
 us to increase the speed of the delivery by NOT having a 
 dictionary keyed lookup mechanism.  Some loss of generality is implied 
 by this.

 This class/system is NOT thread safe, but could be made so with some
 mutex wrappers.  It is safe to call Attach/Detach as a consequence 
 of calling Notify(...).  

 */


class Notified;

class Notifier : public SingletonDynamic<Notifier>
{
public:
   typedef enum
   {
      NE_MIN = 0,
      NE_DEBUG_BUTTON_PRESSED = NE_MIN,
      NE_DEBUG_LINE_DRAW_ADD_LINE_PIXELS,
      NE_DEBUG_TOGGLE_VISIBILITY,
      NE_DEBUG_MESSAGE,
      NE_RESET_DRAW_CYCLE,
      NE_VIEWPORT_CHANGED,
      NE_MAX,
   } NOTIFIED_EVENT_TYPE_T;

private:
   typedef vector<NOTIFIED_EVENT_TYPE_T> NOTIFIED_EVENT_TYPE_VECTOR_T;

   typedef map<Notified*,NOTIFIED_EVENT_TYPE_VECTOR_T> NOTIFIED_MAP_T;
   typedef map<Notified*,NOTIFIED_EVENT_TYPE_VECTOR_T>::iterator NOTIFIED_MAP_ITER_T;

   typedef vector<Notified*> NOTIFIED_VECTOR_T;
   typedef vector<NOTIFIED_VECTOR_T> NOTIFIED_VECTOR_VECTOR_T;

   NOTIFIED_MAP_T _notifiedMap;
   NOTIFIED_VECTOR_VECTOR_T _notifiedVector;
   NOTIFIED_MAP_ITER_T _mapIter;

   // This vector keeps a temporary list of observers that have completely
   // detached since the current "Notify(...)" operation began.  This is
   // to handle the problem where a Notified instance has called Detach(...)
   // because of a Notify(...) call.  The removed instance could be a dead
   // pointer, so don't try to talk to it.
   vector<Notified*> _detached;
   int32 _notifyDepth;

   void RemoveEvent(NOTIFIED_EVENT_TYPE_VECTOR_T& orgEventTypes, NOTIFIED_EVENT_TYPE_T eventType);
   void RemoveNotified(NOTIFIED_VECTOR_T& orgNotified, Notified* observer);

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);

   /* The design of this interface is very specific.  I could 
    * create a class to hold all the event data and then the
    * method would just have take that object.  But then I would
    * have to search for every place in the code that created an
    * object to be used and make sure it updated the passed in
    * object when a member is added to it.  This way, a break
    * occurs at compile time that must be addressed.
    */
   void Notify(NOTIFIED_EVENT_TYPE_T, const void* eventData = NULL);

   /* 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);
};

/* This is the base class for anything that can receive notifications.
 */
class Notified
{
public:
   virtual void Notify(Notifier::NOTIFIED_EVENT_TYPE_T eventType, const void* eventData) = 0;
   virtual ~Notified();

};

typedef Notifier::NOTIFIED_EVENT_TYPE_T NOTIFIED_EVENT_TYPE_T;

NOTE: The Notified class has a single function, Notify(...) here. Because the void* is not type safe, I created other versions where notify looks like:

virtual void Notify(Notifier::NOTIFIED_EVENT_TYPE_T eventType, int value); 
virtual void Notify(Notifier::NOTIFIED_EVENT_TYPE_T eventType, const string& str);

Corresponding Notify(...) methods were added to the Notifier itself. All these used a single function to get the "target list" then called the appropriate function on the targets. This works well and keeps the receiver from having to do ugly casts.

This seems to work well. The solution is posted on the web here along with the source code. This is a relatively new design, so any feedback is greatly appreciated.

Answer 3

#include <algorithm>
#include <vector>


class WeatherFlags
{
public:
    WeatherFlags()
        : mask_(0)
    {}
    union {
        struct {
            unsigned int temperature_ : 1;
            unsigned int humidity_ : 1;
            unsigned int pressure_ : 1;
        };
        unsigned int mask_;
    };
};

class WeatherData;

class WeatherEvent
{
public:
    WeatherEvent(WeatherData* data, WeatherFlags const& flags)
        : data_(data)
        , flags_(flags)
    {}
    double getTemperature() const;

    WeatherData* data_;
    WeatherFlags flags_;  
};

class WeatherListener
{
public:
    virtual ~WeatherListener() = 0;
    virtual void onWeatherUpdate(WeatherEvent& e) = 0;
};
inline WeatherListener::~WeatherListener() {}

class WeatherListenerEntry
{
public:
    WeatherListenerEntry()
        : listener_(0)
    {}
    WeatherListenerEntry(WeatherListener* listener, WeatherFlags const& flags)
        : listener_(listener)
        , flags_(flags)
    {}

    WeatherListener* listener_;
    WeatherFlags flags_;
};

class WeatherData
{
public:
    WeatherData();
    void addListener(WeatherListener* listener, WeatherFlags const& flags);
    void removeListener(WeatherListener* listener);

    void notify(WeatherFlags const& flags);

    double getTemperature() const { return temperature_; }
private:
    typedef std::vector<WeatherListenerEntry> Listeners;
    Listeners listeners_;
    double temperature_;
};

WeatherData::WeatherData()
: temperature_(0)
{}

void WeatherData::addListener(WeatherListener* listener, WeatherFlags const& flags)
{
    // TODO Could maybe check for the addition of duplicates here...
    listeners_.push_back(WeatherListenerEntry(listener, flags));
}

void WeatherData::removeListener(WeatherListener* listener)
{
    struct ListenerEquals {
        WeatherListener* listener_;
        ListenerEquals(WeatherListener* listener)
            : listener_(listener)
        {}
        bool operator()(WeatherListenerEntry const& e) const {
            return (e.listener_ == listener_);
        }
    };
    listeners_.erase(
        std::remove_if(listeners_.begin(), listeners_.end(), ListenerEquals(listener)),
        listeners_.end());
}

void WeatherData::notify(WeatherFlags const& flags)
{
    WeatherEvent evt(this, flags);
    for (Listeners::iterator i = listeners_.begin(); i != listeners_.end(); ++i)
    {
        if (0 != (i->flags_.mask_ & flags.mask_)) {
            i->listener_->onWeatherUpdate(evt);
        }
    }
}

double 
WeatherEvent::getTemperature() const
{
    return data_->getTemperature();
}


#include <iostream>
class WeatherObserverStdout : public WeatherListener
{
public:
    void observe(WeatherData& data) {
        WeatherFlags flags;
        flags.temperature_ = true; // interested in temperature only.
        data.addListener(this, flags);        
    }
    virtual void onWeatherUpdate(WeatherEvent& e);
};

void
WeatherObserverStdout::onWeatherUpdate(WeatherEvent& e)
{
    double temp = e.getTemperature();
    std::cout << "Temperatrure: " << temp << std::endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
    WeatherData wdata;
    WeatherObserverStdout obs;
    obs.observe(wdata);

    WeatherFlags flags;
    wdata.notify(flags);
    flags.temperature_ = true;
    wdata.notify(flags);
    return 0;
}

Answer 4

A more pattern oriented solution (but without function pointers) could be the following. You could parametrize the WeatherObserver-Class to get only the values, you want.

#include <list>
#include <iostream>

class Observable;   //forward declaration

//Base class for all observers
class Observer {
    friend class Observable;    //allow access to observedSubject

protected:
    Observable *observedSubject;

public:
    virtual void update(){};
};


//Base class for all observables
class Observable {
private:
    std::list<Observer * const> m_registeredObservers;

public:
    ~Observable()
    {
        //delete the observers
        std::list<Observer * const>::iterator it = m_registeredObservers.begin();

        while (it != m_registeredObservers.end())
        {
            delete *it;
            it = m_registeredObservers.erase(it);
        }
    }

    void addObserver(Observer * const _pObserver)
    {
        _pObserver->observedSubject = this;
        m_registeredObservers.push_back(_pObserver);
    }

    void removeObserver(Observer * const _pObserver)
    {
        m_registeredObservers.remove(_pObserver);
        delete _pObserver;
    }

    void notifyObservers()
    {
        std::list<Observer * const>::iterator it = m_registeredObservers.begin();

        while (it != m_registeredObservers.end())
        {
            (*it)->update();
            it++;
        }
    }
};

//Concrete Observable
class WeatherData : public Observable {
private:
    float temperature;
    float humidity;
    float pressure;

public:
    WeatherData(): temperature(0), humidity(0), pressure(0)
    {};

    float getTemperature () const 
    {
        return temperature;
    }

    float getHumidity () const 
    {
        return humidity;
    }

    float getPressure () const 
    {
        return pressure;
    }

    void setTemperature(float _temperature)
    {
        if (temperature != _temperature)
        {
            temperature = _temperature;
            notifyObservers();
        }
    }

    void setHumidity(float _humidity)
    {
        if (humidity != _humidity)
        {
            humidity = _humidity;
            notifyObservers();
        }
    }

    void setPressure(float _pressure)
    {
        if (pressure != _pressure)
        {
            pressure = _pressure;
            notifyObservers();
        }
    }

};


//Concrete implementation of an weather observer
class WeatherObserver : public Observer 
{
    public:
        WeatherObserver():Observer(){};
        void update()
        {
            WeatherData* pWeatherPtr = static_cast<WeatherData*>(observedSubject);
            if (pWeatherPtr != 0)
            {
                float actHumidity = pWeatherPtr->getHumidity();
                float actPressure = pWeatherPtr->getPressure();
                float actTemperature = pWeatherPtr->getTemperature();

                //do something with the data
                std::cout << "WeatherObserver update" << std::endl;
                std::cout << "Temperature : " << actTemperature << std::endl;
                std::cout << "Humidity : " << actHumidity << std::endl;
                std::cout << "Pressure : " << actPressure << std::endl;
            }
        }
};

int main()
{
    WeatherData weatherData;
    Observer * pObserver = new WeatherObserver();
    weatherData.addObserver(pObserver);

    weatherData.setHumidity(100);
    weatherData.setTemperature(100);
}

Answer 5

I think it is easier, and more scalable, to define a set of event types that each observer can listen to. Then you register the observer to listen to that particular event type. The observed then keeps a list of observers registered for each event, and notifies them if and when the event occurs. Using a combination of std::function, std::bind (or boost equivalents), it is easy to register callbacks for a given event type. You could put the callbacks in a map of event type to callback.

For example, something along these lines (almost pseudo-code, has not been tested)

class Publisher {

 public :
  void subscribe(const std::string& event, 
                 std::function<void(double)> callback) {
    m_subscribers[s].push_back(callback);    
  }
  void publish(const std::string& event) const {
    for (auto& f : m_subscribers[event]) f( some double );}

  void event(const std::string& event) const { publish(event);}

 private:
  // map of event types (here simply strings) to list of callbacks
  std::map<std::string&, 
           std::list<std::function<void(const std::string&)>>> m_subscribers;
};

struct Foo {
  void foo(double x) {
  std::cout << "Foo received message: " << x << "\n";
  }
};

struct Bar {
  void bar(double x) {
  std::cout << "Bar received message: " << x << "\n";
  }
};

int main() {
  Publisher pub;
  Foo f0;
  Foo f1;
  Bar bar0;

  pub.subscribe("RED", std::bind(&Foo::foo, &foo0, _1));
  pub.subscribe("GREEN", std::bind(&Foo::foo, &foo1, _1));
  pub.subscribe("WHITE", std::bind(&Foo::foo, &foo1, _1));
  pub.subscribe("RED", std::bind(&Bar::bar, &bar0, _1));
  pub.subscribe("BLUE", std::bind(&Bar::bar, &bar0, _1));
  pub.subscribe("MAGENTA", std::bind(&Bar::bar, &bar0, _1));

  // trigger a "GREEN" event
  pub.event("GREEN");

}

Here, the observers (or subscribers) register to some events, represented by strings here, and their registered callbacks get called when this event happens. In the example above I manually trigger an event to illustrate the mechanism.

This event-callback mechanism allows to decouple the actual items from the callback action. The Observed (or publisher) knows what parameter to pass the callback for a given event, and which callbacks to call, so the observers are not dependent on the internal data of the observed object.