Signal.h

#ifndef UTIL_SIGNAL_H
#define UTIL_SIGNAL_H
 
/*
* Util Package - C++ Utilities for Scientific Computation
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include "IFunctor.h"
#include "MethodFunctor.h"
 
#include <list>
 
namespace Util
{
 
   using std::list;
 
   // -----------------------------------------------------------------
   // Signal with one argument.
 
   template <typename T=void>
   class Signal
   {
   
   public:
 
      // Compiler default constructor.
 
      Signal(){};
  
      ~Signal();
  
      template <class Observer>
      void addObserver(Observer& observer, void (Observer::*methodPtr)(const T&));
 
      void clear();   
 
      int nObserver() const;
   
      void notify(const T& t);
 
   private:
   
      std::list<IFunctor<T>*> functorPtrs_;
 
      Signal(const Signal<T>& other);
 
      Signal<T>& operator = (const Signal<T>& other);
 
   };
 
   /*
   * Destructor.
   */
   template <typename T>
   Signal<T>::~Signal()
   {  clear(); }
 
   /* 
   * Register an observer (add to list).
   */
   template <typename T>
   template <class Observer> void 
   Signal<T>::addObserver(Observer& observer, void (Observer::*methodPtr)(const T&))
   {  functorPtrs_.push_back(new MethodFunctor<Observer, T>(observer, methodPtr)); }
 
   /* 
   * Notify observers (call associated methods).
   */
   template <typename T>
   void Signal<T>::notify(const T& t)
   {
      typename std::list< IFunctor<T>* >::iterator pos;
      pos = functorPtrs_.begin();
      while (pos != functorPtrs_.end())
      {
         (**pos)(t);
         ++pos;
      }
   }
 
   /* 
   * Clear all observers.
   *
   * Destroy associated functors.
   */
   template <typename T>
   void Signal<T>::clear()
   {
      typename std::list< IFunctor<T>* >::iterator pos;
      pos = functorPtrs_.begin();
      while (pos != functorPtrs_.end())
      {
         delete *pos;
         ++pos;
      }
      functorPtrs_.clear();
   }
 
   /* 
   * Get number of registered observers.
   */
   template <typename T>
   int Signal<T>::nObserver() const
   { return functorPtrs_.size(); }
 
 
   // -----------------------------------------------------------------
   // Signal with no arguments.
 
   template <>
   class Signal<void>
   {
   
   public:
 
      Signal(){};
 
      ~Signal();
  
      template <class Observer>
      void addObserver(Observer& observer, void (Observer::*methodPtr)());
   
      void clear();   
 
      int nObserver() const;
 
      void notify();
   
   private:
   
      std::list<IFunctor<>*> functorPtrs_;
 
      Signal(const Signal<>& other);
 
      Signal<>& operator = (const Signal<>& other);
 
   };
 
   /* 
   * Register an observer (add to list).
   */
   template <class Observer> void 
   Signal<>::addObserver(Observer& observer, void (Observer::*methodPtr)())
   {  functorPtrs_.push_back(new MethodFunctor<Observer>(observer, methodPtr)); }
 
}
#endif