ObserverSubjectBase.h

Go to the documentation of this file.

#ifndef _OCRA_OBSERVER_SUBJECT_BASE_H_
#define _OCRA_OBSERVER_SUBJECT_BASE_H_

#include <functional>
#include <algorithm>

#include <boost/any.hpp>
#include <boost/type_traits/is_class.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/static_assert.hpp>
#include <boost/ptr_container/ptr_vector.hpp>

namespace ocra
{
  // ------------------------------------------------------------
  // --- INVOKER ------------------------------------------------
  // ------------------------------------------------------------

  template<int EVT> class ObserverBase;


  template<int EVT>
  class InvokerBase
  {
  protected:
    typedef ObserverBase<EVT> observer_base_type;
    typedef void (observer_base_type::*member_callback_type)(int);
    typedef void (*free_callback_type)(int);

  public:
    virtual ~InvokerBase() {} // Invoker instances are polymorphically destroyed by SubjectBase.

    template<class T>
    bool isObserverEqualTo(std::pair<T*, void (T::*)(int)> observer)
    {
      return observer.first == getObject() && isCallbackEqualTo(observer.second);
    }

    template<class T>
    bool isCallbackEqualTo(void (T::*callback)(int))
    {
      bool result;
      try {
        result = callback == boost::any_cast<void (T::*)(int)>(getCallback());
      }
      catch(boost::bad_any_cast&) {
        result = false;
      }
      return result;
    }

    bool isCallbackEqualTo(void (*callback)(int))
    {
      bool result;
      try {
        result = callback == boost::any_cast<void (*)(int)>(getCallback());
      }
      catch(boost::bad_any_cast&) {
        result = false;
      }
      return result;
    }

  public:

    virtual void trigger(int timestamp) = 0;

  protected:
    virtual boost::any getCallback() = 0;
    virtual void* getObject() = 0;
  };


  // ------------------------------------------------------------

  template<class T, int EVT, bool T_isDerivedFromObserverBase> class Invoker
  {
  };


  // ------------------------------------------------------------

  template<class T, int EVT>
  class Invoker<T, EVT, true /*meaning: ObserverBase<EVT> is base of T*/>
    : public InvokerBase<EVT>
  {
  public:
    Invoker(T& object, void (T::*callback)(int)): object_(object), callback_(callback), timestamp_(-1) {}

    void trigger(int timestamp)
    {
      object_.InvokerBase<EVT>::observer_base_type::trigger(object_, callback_, timestamp, timestamp_);
    }

  protected:
    boost::any getCallback() { return boost::any(callback_); }
    void* getObject() { return &object_; }

  private:
    T& object_;
    void (T::*callback_)(int);
    int timestamp_;
  };


  // ------------------------------------------------------------

  template<class T, int EVT>
  class Invoker<T, EVT, false /*meaning: ObserverBase<EVT> is NOT a base of T*/>
    : public InvokerBase<EVT>
  {
  public:
    Invoker(T& object, void (T::*callback)(int)): object_(object), callback_(callback) {}

    void trigger(int timestamp) { if(callback_) (object_.*callback_)(timestamp); }

  protected:
    boost::any getCallback() { return boost::any(callback_); }
    void* getObject() { return &object_; }

  private:
    T& object_;
    void (T::*callback_)(int);
  };


  // ------------------------------------------------------------

  template<int EVT>
  class Invoker<void, EVT, false /*true would have no meaning in the free function case*/>
    : public InvokerBase<EVT>
  {
  public:
    Invoker(void (*callback)(int)): callback_(callback) {}

    void trigger(int timestamp) { if(callback_) (*callback_)(timestamp); }

  protected:
    boost::any getCallback() { return boost::any(callback_); }
    void* getObject() { return 0x0; }

  private:
    void (*callback_)(int);
  };

  // ------------------------------------------------------------

  template<int EVT>
  class Invoker<void, EVT, true>
  {
  };


  // ------------------------------------------------------------
  // --- OBSERVER_BASE ------------------------------------------
  // ------------------------------------------------------------

  template<int EVT> class SubjectBase;


  template<int EVT>
  class ObserverBase
  {
  protected:
    typedef SubjectBase<EVT>          subject_type;
    typedef InvokerBase<EVT>          invoker_type;

  public:
    void bind(subject_type& subject) { subject_ = &subject; }

  protected:
    void stopPropagation() { propagate_ = false; }

    ObserverBase(): subject_(0x0), propagate_(true) {}
    ~ObserverBase() {}

  private:
    template<class T>
    void trigger(T& object, void (T::*callback)(int), int timestamp, int& savedTimestamp)
    {
      if(timestamp > savedTimestamp)
      {
        savedTimestamp = timestamp;
        propagate_ = true;
        if(callback)
          (object.*callback)(timestamp);
        if(propagate_ && subject_)
          subject_->propagate(timestamp);
      }
    }

    subject_type* subject_;
    bool propagate_;

    template<class, int, bool> friend class Invoker;
  };


  // ------------------------------------------------------------
  // --- SUBJECT_BASE -------------------------------------------
  // ------------------------------------------------------------


  template<int EVT> struct SubjectBaseTraitsBase {
    typedef InvokerBase<EVT>                                                  invoker_base_type;
  };
  
  template<int EVT, class T>
  struct SubjectBaseTraits : SubjectBaseTraitsBase<EVT>
  {
    typedef typename SubjectBaseTraitsBase<EVT>::invoker_base_type            invoker_base_type;
    typedef                                                                   void (T::*callback_type)(int);
    typedef Invoker<T, EVT,boost::is_base_of<ObserverBase<EVT>, T>::value>    invoker_type;
    typedef std::pair<T*, callback_type>                                      invoker_id_type;
    typedef std::mem_fun1_ref_t<bool, invoker_base_type, invoker_id_type>     invoker_comparator_type;
  };

  template<int EVT> 
  struct SubjectBaseTraits<EVT, void> : SubjectBaseTraitsBase<EVT>
  {
    typedef typename SubjectBaseTraitsBase<EVT>::invoker_base_type            invoker_base_type;
    typedef                                                                   void (*callback_type)(int);
    typedef Invoker<void, EVT,false>                                          invoker_type;
    typedef callback_type                                                     invoker_id_type;
    typedef std::mem_fun1_ref_t<bool, invoker_base_type, invoker_id_type>     invoker_comparator_type;
  };

  template<int EVT>
  class SubjectBase
  {
  private:
    typedef typename SubjectBaseTraitsBase<EVT>::invoker_base_type            invoker_base_type;
  protected:
    SubjectBase() {}
    ~SubjectBase() {}

  public:
    template<class T>
    void connect(T& object, typename SubjectBaseTraits<EVT, T>::callback_type newCallback) const
    {
      BOOST_STATIC_ASSERT(boost::is_class<T>::value); // Avoid passing (void*,int*,char*,...)
      observers_.push_back(new typename SubjectBaseTraits<EVT, T>::invoker_type(object, newCallback));
    }

    void connect(typename SubjectBaseTraits<EVT, void>::callback_type newCallback) const
    {
      observers_.push_back(new typename  SubjectBaseTraits<EVT, void>::invoker_type(newCallback));
    }

    template<class T>
    void disconnect(T& object, typename SubjectBaseTraits<EVT, T>::callback_type callback) const
    {
      BOOST_STATIC_ASSERT(boost::is_class<T>::value);

      typename SubjectBaseTraits<EVT, T>::invoker_comparator_type comparator = std::mem_fun_ref(&invoker_base_type::template isObserverEqualTo<T>);
      typename SubjectBaseTraits<EVT, T>::invoker_id_type elementToErase(&object, callback);

      observers_.erase_if( std::bind2nd(comparator, elementToErase) );
    }

    void disconnect(typename SubjectBaseTraits<EVT, void>::callback_type callbackToErase) const
    {
      typename SubjectBaseTraits<EVT, void>::invoker_comparator_type comparator =  
        std::mem_fun_ref<bool, invoker_base_type, void (*)(int)>(&invoker_base_type::isCallbackEqualTo);
      observers_.erase_if( std::bind2nd(comparator, callbackToErase) );
    }

    void propagate(int timestamp) const
    {
      std::mem_fun1_ref_t<void, invoker_base_type, int> trigger = std::mem_fun_ref(&invoker_base_type::trigger);
      std::for_each(observers_.begin(), observers_.end(), std::bind2nd(trigger, timestamp));
    }

    void propagate() const { static int timestamp = 0; propagate(++timestamp); }

  private:
    mutable boost::ptr_vector<invoker_base_type> observers_;
  };
}

#endif

// cmake:sourcegroup=utils