How to handle Observables with different state-value types in the Observer

Question

(Context and question first, skeleton code at the bottom of the post)

We are creating and implementing a C++ framework to use in environments like Arduino.

For this I want to use the Observer pattern, where any component interested in state-changes of sensors (Observables) can register itself and it will get notified of those changes by the Observable calling the notification() method of the Observer with itself as a parameter.

One Observer can observe multiple Observables, and vice versa.

The problem lies in the fact that the Observer needs to extract the current state of the Observable and do something with it, and this current state can take all forms and sizes, depending on the particular sensor that is the Observable.

It can of course be ordinal values, which are finite and can be coded out, like I did in the code below with the method getValueasInt() but it can also be sensor-specific structures, i.e. for a RealTimeClock, which delivers a struct of date and time values. The struct are of course defined at compile time, and fixed for a specific sensor.

My question: What is the most elegant, and future-modification proof solution or pattern for this ?

Edit: Note that dynamic_cast<> constructions are not possible because of Arduino limitations

---

I have created the following class-hierarchy (skeleton code):

class SenseNode
{
public:
  SenseNode() {};
  SenseNode(uint8_t aNodeId): id(aNodeId) {}
  virtual ~SenseNode() {}

  uint8_t getId() { return id; };
private:
  uint8_t id = 0;
};

class SenseStateNode : virtual public SenseNode
{
public:
  SenseStateNode(uint8_t aNodeId) : SenseNode(aNodeId) {}
  virtual ~SenseStateNode() {}

  /** Return current node state interpreted as an integer. */
  virtual int getValueAsInt();
};

class SenseObservable: public SenseStateNode
{
public:
  SenseObservable(uint8_t aNodeId);
  virtual ~SenseObservable();
  /** Notify all interested observers of the change in state by calling Observer.notification(this) */
  virtual void notifyObservers();
protected:
  virtual void registerObserver(SenseObserver *);
  virtual void unregisterObserver(SenseObserver *);
};

class SenseObserver: virtual public SenseNode
{
public:
  SenseObserver() {};
  virtual ~SenseObserver();

  /** Called by an Observable that we are observing to inform us of a change in state */
  virtual void notification(SenseObservable *observable) {
    int v = observable->getValueAsInt(); // works like a charm
    DateTime d = observable-> ????  // How should i solve this elegantly?
  };
};

---

Answer 1

My previous answer does not take into account that the same observer might me registered with different observables. I'll try to give a full solution here. The solution is very flexible and scalable but a bit hard to understand as it involves template meta programming (TMP). I'll start by outlining what the end result will look like and then move into the TMP stuff. Brace yourself, this is a LONG answer. Here we go:

We first have, for the sake of the example, three observables, each with its own unique interface which we will want later to access from the observer.

#include <vector>
#include <algorithm>
#include <iostream>
#include <unordered_map>
#include <string>

class observable;

class observer {

public:

    virtual void notify(observable& x) = 0;
};

// For simplicity, I will give some default implementation for storing the observers
class observable {

    // assumping plain pointers
    // leaving it to you to take of memory
    std::vector<observer*> m_observers;

public:

    observable() = default;

    // string id for identifying the concrete observable at runtime
    virtual std::string id() = 0;

    void notifyObservers() {
        for(auto& obs : m_observers) obs->notify(*this);
    }

    void registerObserver(observer* x) {
        m_observers.push_back(x);
    }

    void unregisterObserver(observer*) {
        // give your implementation here
    }

    virtual ~observable() = default;
};

// our first observable with its own interface
class clock_observable
: public observable {

    int m_time;

public:

    clock_observable(int time)
    : m_time(time){}

    // we will use this later
    static constexpr auto string_id() {
        return "clock_observable";
    }

    std::string id() override {
        return string_id();
    }

    void change_time() {
        m_time++;
        notifyObservers(); // notify observes of time change
    }

    int get_time() const {
        return m_time;
    }
};

// another observable
class account_observable
: public observable {

    double m_balance;

public:

    account_observable(double balance)
    : m_balance(balance){}

    // we will use this later
    static constexpr auto string_id() {
        return "account_observable";
    }

    std::string id() override {
        return string_id();
    }

    void deposit_amount(double x) {
        m_balance += x;
        notifyObservers(); // notify observes of time change
    }

    int get_balance() const {
        return m_balance;
    }
};

class temperature_observable
: public observable {

    double m_value;

public:

    temperature_observable(double value)
    : m_value(value){}

    // we will use this later
    static constexpr auto string_id() {
        return "temperature_observable";
    }

    std::string id() override {
        return string_id();
    }

    void increase_temperature(double x) {
        m_value += x;
        notifyObservers(); // notify observes of time change
    }

    int get_temperature() const {
        return m_value;
    }
};

Notice that each observer exposes an id function returning a string which identifies it. Now, let's assume we want to create an observer which monitors the clock and the account. We could have something like this:

class simple_observer_clock_account
: public observer {

    std::unordered_map<std::string, void (simple_observer_clock_account::*) (observable&)> m_map;

    void notify_impl(clock_observable& x) {
        std::cout << "observer says time is " << x.get_time() << std::endl;
    }

    void notify_impl(account_observable& x) {
        std::cout << "observer says balance is " << x.get_balance() << std::endl;
    }

    // casts the observable into the concrete type and passes it to the notify_impl
    template <class X>
    void dispatcher_function(observable& x) {
        auto& concrete = static_cast<X&>(x);
        notify_impl(concrete);
    }

public:

    simple_observer_clock_account() {
        m_map[clock_observable::string_id()] = &simple_observer_clock_account::dispatcher_function<clock_observable>;
        m_map[account_observable::string_id()] = &simple_observer_clock_account::dispatcher_function<account_observable>;
    }

    void notify(observable& x) override {
        auto f = m_map.at(x.id());
        (this->*f)(x);
    }
};

I am using an unoderded_map so that the correct dispatcher_function will be called depending on the id of the observable. Confirm that this works:

int main() {

    auto clock = new clock_observable(100);
    auto account = new account_observable(100.0);

    auto obs1 = new simple_observer_clock_account();

    clock->registerObserver(obs1);
    account->registerObserver(obs1);

    clock->change_time();
    account->deposit_amount(10);
}

A nice thing about this implementation is that if you try to register the observer to a temperature_observable you will get a runtime exception (as the m_map will not contain the relevant temperature_observable id).

This works fine but if you try now to adjust this observer so that it can monitor temperature_observables, things get messy. You either have to go edit the simple_observer_clock_account (which goes against the closed for modification, open for extension principle), or create a new observer as follows:

class simple_observer_clock_account_temperature
: public observer {

    std::unordered_map<std::string, void (simple_observer_clock_account_temperature::*) (observable&)> m_map;

    // repetition
    void notify_impl(clock_observable& x) {
        std::cout << "observer1 says time is " << x.get_time() << std::endl;
    }

    // repetition
    void notify_impl(account_observable& x) {
        std::cout << "observer1 says balance is " << x.get_balance() << std::endl;
    }

    // genuine addition
    void notify_impl(temperature_observable& x) {
        std::cout << "observer1 says temperature is " << x.get_temperature() << std::endl;
    }

    // repetition
    template <class X>
    void dispatcher_function(observable& x) {
        auto& concrete = static_cast<X&>(x);
        notify_impl(concrete);
    }

public:

    // lots of repetition only to add an extra observable
    simple_observer_clock_account_temperature() {
        m_map[clock_observable::string_id()] = &simple_observer_clock_account_temperature::dispatcher_function<clock_observable>;
        m_map[account_observable::string_id()] = &simple_observer_clock_account_temperature::dispatcher_function<account_observable>;
        m_map[temperature_observable::string_id()] = &simple_observer_clock_account_temperature::dispatcher_function<temperature_observable>;
    }

    void notify(observable& x) override {
        auto f = m_map.at(x.id());
        (this->*f)(x);
    }
};

This works but it is a hell of a lot repetitive for just adding one additional observable. You can also imagine what would happen if you wanted to create any combination (ie account + temperature observable, clock + temp observable, etc). It does not scale at all.

The TMP solution essentially provides a way to do all the above automatically and re-using the overriden implementations as opposed to replicating them again and again. Here is how it works:

We want to build a class hierarchy where the base class will expose a number of virtual notify_impl(T&) method, one for each T concrete observable type that we want to observe. This is achieved as follows:

template <class Observable>
class interface_unit {

public:

    virtual void notify_impl(Observable&) = 0;
};

// combined_interface<T1, T2, T3> would result in a class with the following members:
// notify_impl(T1&)
// notify_impl(T2&)
// notify_impl(T3&)
template <class... Observable>
class combined_interface
: public interface_unit<Observable>...{

    using self_type = combined_interface<Observable...>;
    using dispatcher_type = void (self_type::*)(observable&);
    std::unordered_map<std::string, dispatcher_type> m_map;

public:

    void map_register(std::string s, dispatcher_type dispatcher) {
        m_map[s] = dispatcher;
    }

    auto get_dispatcher(std::string s) {
        return m_map.at(s);
    }

    template <class X>
    void notify_impl(observable& x) {
        interface_unit<X>& unit = *this;
        // transform the observable to the concrete type and pass to the relevant interface_unit.
        unit.notify_impl(static_cast<X&>(x));
    }
};

The combined_interface class inherits from each interface_unit and also allows us to register functions to the map, similarly to what we did earlier for the simple_observer_clock_account. Now we need to create a recursive hierarchy where at each step of the recursion we override notify_impl(T&) for each T we are interested in.

// forward declaration
// Iface will be combined_interface<T1, T2>
// The purpose of this class is to implement the virtual methods found in the Iface class, ie notify_impl(T1&), notify_impl(T2&)
// Each ImplUnit provides an override for a single notify_impl(T&)
// Root is the base class of the hierarchy; this will be the data (if any) held by the observer
template <class Root, class Iface, template <class, class> class... ImplUnits>
struct hierarchy;

// recursive
template <class Root, class Iface, template <class, class> class ImplUnit, template <class, class> class... ImplUnits>
struct hierarchy<Root, Iface, ImplUnit, ImplUnits...>
: public ImplUnit< hierarchy<Root, Iface, ImplUnits...>, Root > {

    using self_type = hierarchy<Root, Iface, ImplUnit, ImplUnits...>;
    using base_type = ImplUnit< hierarchy<Root, Iface, ImplUnits...>, Root >;

public:

    template <class... Args>
    hierarchy(Args&&... args)
    : base_type{std::forward<Args>(args)...} {

        using observable_type = typename base_type::observable_type;
        Iface::map_register(observable_type::string_id(), &Iface::template notify_impl<observable_type>);
    }
};

// specialise if we have iterated through all ImplUnits
template <class Root, class Iface>
struct hierarchy<Root, Iface>
: public Root
, public observer
, public Iface {

public:

    template <class... Args>
    hierarchy(Args&&... args)
    : Root(std::forward<Args>(args)...)
    , Iface(){}
};

At each step of the recursion, we register the dispatcher_function to our map.

Finally, we create a class which will be used for our observers:

template <class Root, class Iface, template <class, class> class... ImplUnits>
class observer_base
: public hierarchy<Root, Iface, ImplUnits...> {

public:

    using base_type = hierarchy<Root, Iface, ImplUnits...>;

    void notify(observable& x) override {
        auto f = this->get_dispatcher(x.id());
        return (this->*f)(x);
    }

    template <class... Args>
    observer_base(Args&&... args)
    : base_type(std::forward<Args>(args)...) {}
};

Let's now create some observables. For simplicity, I assume that the observer has not data:

class observer1_data {};

// this is the ImplUnit for notify_impl(clock_observable&)
// all such implementations must inherit from the Super argument and expose the observable_type type member
template <class Super, class ObserverData>
class clock_impl
: public Super {

public:

    using Super::Super;
    using observable_type = clock_observable;

    void notify_impl(clock_observable& x) override {
        std::cout << "observer says time is " << x.get_time() << std::endl;
    }
};

template <class Super, class ObserverdData>
class account_impl
: public Super {

public:

    using Super::Super;
    using observable_type = account_observable;

    void notify_impl(account_observable& x) override {
        std::cout << "observer says balance is " << x.get_balance() << std::endl;
    }
};

template <class Super, class ObserverdData>
class temperature_impl
: public Super {

public:

    using Super::Super;
    using observable_type = temperature_observable;

    void notify_impl(temperature_observable& x) override {
        std::cout << "observer says temperature is " << x.get_temperature() << std::endl;
    }
};

Now we can easily create any observer we want, no matter what combinations we want to use:

using observer_clock =  observer_base<observer1_data,
combined_interface<clock_observable>,
clock_impl>;

using observer_clock_account =  observer_base<observer1_data,
combined_interface<clock_observable, account_observable>,
clock_impl, account_impl>;

using observer_clock_account_temperature =  observer_base<observer1_data,
combined_interface<clock_observable, account_observable, temperature_observable>,
clock_impl, account_impl, temperature_impl>;

int main() {

    auto clock = new clock_observable(100);
    auto account = new account_observable(100.0);
    auto temp = new temperature_observable(36.6);

    auto obs1 = new observer_clock_account_temperature();

    clock->registerObserver(obs1);
    account->registerObserver(obs1);
    temp->registerObserver(obs1);


    clock->change_time();
    account->deposit_amount(10);
    temp->increase_temperature(2);
}

I can appreciate there is a lot to digest. Anyway, I hope it is helpful. If you want to understand in detail the TMP ideas above have a look at the Modern C++ design by Alexandrescu. One of the best I've read.

Let me know if anything is not clear and I will edit the answer.