periodicthread.hpp

#ifndef DDF_PERIODICTHREAD_HPP
#define DDF_PERIODICTHREAD_HPP

#include "stopwatch.hpp"

namespace jafar
{
  namespace ddf
  {

    class Timer_Command
    {
    private:
      bool    m_kill;   // if true then the thread function returns
      bool    m_run;    // if true then execute the thread function
      bool    m_initialized;
      mutable   boost::mutex  m_mutex;  // mutex in case the process is controlled by different entities
      
    public:
      Timer_Command(): m_kill(false), m_run(false), m_initialized(false) { }

      void Kill(bool val) { boost::mutex::scoped_lock lock(m_mutex); m_kill = val; }
      void Run(bool val) { boost::mutex::scoped_lock lock(m_mutex); m_run = val; m_initialized = !m_run; }
      bool IsRunning() {  return m_run; }
      bool IsInitialized() { boost::mutex::scoped_lock lock(m_mutex); return m_initialized;}
      void SetInitialized() { boost::mutex::scoped_lock lock(m_mutex); m_initialized = true; }
      bool IsKilled() { return m_kill; }
    };

    template<typename T>
    class Thread_Periodic_Func
    {
   
    private:
      time  m_period;       // time interval between two calls of the process function
      Timer_Command &m_pth_cmd;   // control the execution of the thread
      T *m_parent;        // a pointer on the parent, which created the thread

    public:

      Thread_Periodic_Func(time period, Timer_Command &pth_cmd, T *obj)
        : m_period(period), m_pth_cmd(pth_cmd) { m_parent = obj; }

      ~Thread_Periodic_Func() { }

      void operator()()
      {
        StopWatch period_check;
        time  horizon = time::current();
        time  elapsed, t_tmp(0,20000);
        bool first = true;
        int call_nr = 0;

        while(1)
            {
              if(m_pth_cmd.IsRunning())
              {
                if(first) // do it only once after Start() is called
                {
                  horizon = m_parent->GetNextHorizon();
                  period_check.Restart();
                  first = false;
                  m_pth_cmd.SetInitialized();
                }
                else
                {
                  horizon = horizon + m_period;
                  m_parent->SetNextHorizon(horizon);
                }

              // Wait until the next time horizon
              horizon.sleep_until();
               
              if (m_pth_cmd.IsRunning())
              {
                // Get the elapsed time since the previous call
                elapsed = period_check.ElapsedAndReset();
                     
                // Exec main func
                m_parent->ExecSyncThreadFunc(horizon, elapsed, call_nr++);
              }
            }
            else {
              first = true;
              call_nr = 0;
              t_tmp.sleep_period(); // for avoiding the sensornode starvation (cmd.Run, Kill etc.)
              // give a chance to the other process to get the mutex
            }
            
            if(m_pth_cmd.IsKilled()) break;
          }
      }
    };

  } // namespace ddf
} // namespace jafar
#endif