Implementing Observer pattern when observers wish to observe different items

Aquarius_Girl · 05-02-2012, 03:13 AM

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.

Code:

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

-EDIT-
Another way can be to implement a global table which'll contain the following:

Code:

Observer | Item to be observed | Function pointer addresss

Observer will fill up this table, and subject will read from the table and act accordingly?

Which one is the better way out, and why?

dugan · 05-02-2012, 09:11 AM

Code:

class WeatherData
{
public:
    void registerTemperatureObserver(Observer *);
    void registerHumidityObserver(Observer *);
private:
    vector<shared_ptr<Observer *>> temperatureObservers;
    void notifyTemperatureObservers();
    vector<shared_ptr<Oberver *>> humidityObservers;
    void notifyHumidityObservers();
}

class Observer
{
public:
    virtual void notify(float) = 0;
}

sundialsvcs · 05-02-2012, 09:27 AM

Definitely a better approach. If a client wants to observe more than one thing, let it register itself separately for each thing it wants to observe.

There are lots of ways to design such a thing, and I try to keep it as simple as possible. I do tend to design such systems such that, if a client wanted, say, to "observe temperature," the client is not only obliged to register itself as a temperature-observer, but also to define a particular method within itself, which anyone who wants to observe temperatures must implement appropriately. This is a simple but effective way to detect accidentally associating an observer-subscription with the wrong kind of handling routine. (It also simplifies the semantics of getting data to it, since both parties understand the abstract interface that each of them will use.) An object that wants to observe more than one thing would implement all of the required interfaces and then register itself, one by one, for everything it wants to observe.