observer.h

Go to the documentation of this file.

#ifndef OBSERVER_H
#define OBSERVER_H
#include "null_deleter.h"
#include "generic_object.h"
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/foreach.hpp>
#include <list>
#include <vector>
#include <iostream>
namespace FullPhysics {
template<class T> class Observable;
/****************************************************************/
template<class T> class Observer : public virtual GenericObject {
public:
  Observer() {
    this_obj = to_ptr(*this);
  }
  virtual ~Observer() {}

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

  virtual void notify_update(const T& Observed_object) {};

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

  virtual void notify_add(T& Observed_object) {}
  virtual void notify_add() {}

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

  virtual void notify_remove(T& Observed_object) {}
  virtual void notify_remove() {}

private:
  // Shared ptr that we can use to get weak_ptr to. This object has
  // exactly the same lifetime as the containing object.
  boost::shared_ptr<Observer> this_obj;
  friend class Observable<T>;
};

/****************************************************************/
template<class T> class Observable : public virtual GenericObject {
public:
  virtual ~Observable() {}

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

  virtual void add_observer(Observer<T>& Obs) = 0;

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

  void add_observer_and_keep_reference
  (boost::shared_ptr<Observer<T> >& Obs) 
  { ref_list.push_back(Obs); add_observer(*Obs); }

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

  virtual void remove_observer(Observer<T>& Obs) = 0;
protected:
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
  void notify_update_do(const T& Self)
  {
    clean_dead_ptr();
    BOOST_FOREACH(boost::weak_ptr<Observer<T> >& t, olist) {
      boost::shared_ptr<Observer<T> > t2 = t.lock();
      if(t2)
        t2->notify_update(Self);
    }
  }

//-----------------------------------------------------------------------
// Helper class for comparing against the weak_ptrs used to keep track
// of observables
//-----------------------------------------------------------------------

  class PointerEqual {
  public:
    PointerEqual(Observer<T>* t) : t_(t) {}
    bool operator()(const boost::weak_ptr<Observer<T> >& w)
    { return w.lock().get() == t_; }
    Observer<T>* t_;
  };

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

  void add_observer_do(Observer<T>& Obs, T& t)
  {
    PointerEqual p(Obs.this_obj.get());
    bool already_added = std::find_if(olist.begin(), olist.end(), p) != olist.end();
    if (!already_added) {
      olist.push_back(boost::weak_ptr<Observer<T> >(Obs.this_obj));
      Obs.notify_add(t);
      Obs.notify_add();
    }
  }

  void add_observer_do(Observer<T>& Obs)
  {
    PointerEqual p(Obs.this_obj.get());
    bool already_added = std::find_if(olist.begin(), olist.end(), p) != olist.end();
    if (!already_added) {
      olist.push_back(boost::weak_ptr<Observer<T> >(Obs.this_obj));
      Obs.notify_add();
    }
  }

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

  void remove_observer_do(Observer<T>& Obs, T& t)
  {
    PointerEqual p(Obs.this_obj.get());
    olist.remove_if(p);
    Obs.notify_remove(t);
    Obs.notify_remove();
  }

  void remove_observer_do(Observer<T>& Obs)
  {
    PointerEqual p(Obs.this_obj.get());
    olist.remove_if(p);
    Obs.notify_remove();
  }

  class PointerDead {
  public:
    bool operator()(const boost::weak_ptr<Observer<T> >& w)
    { return w.expired(); }
  };
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
  void clean_dead_ptr() {
    PointerDead p;
    olist.remove_if(p);
  }
  std::list<boost::weak_ptr<Observer<T> > > olist;
  std::vector<boost::shared_ptr<Observer<T> > > ref_list;
};  
}
#endif