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