PeriodicTask.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef COIL_PERIODICTASK_H
#define COIL_PERIODICTASK_H

#include <map>
#include <string>
#include <vector>
#include <algorithm>

#include <coil/Mutex.h>
#include <coil/Guard.h>
#include <coil/Condition.h>
#include <coil/TimeValue.h>
#include <coil/TimeMeasure.h>
#include <coil/PeriodicTaskBase.h>

namespace coil
{
  class PeriodicTask
    : public coil::PeriodicTaskBase
  {
  public:
    typedef coil::Guard<coil::Mutex> Guard;

    PeriodicTask();
    
    virtual ~PeriodicTask();
    
    virtual void activate();

    virtual void finalize();

    virtual int suspend(void);

    virtual int resume(void);

    virtual void signal();

    virtual bool setTask(TaskFuncBase* func, bool delete_in_dtor = true);

    template <class O, class F>
    bool setTask(O* obj, F fun)
    {
      return this->setTask(new TaskFunc<O, F>(obj, fun));
    }

    virtual void setPeriod(double period);

    virtual void setPeriod(TimeValue& period);

    virtual void executionMeasure(bool value);
    
    virtual void executionMeasureCount(int n);
    
    virtual void periodicMeasure(bool value);
    
    virtual void periodicMeasureCount(int n);
    
    virtual TimeMeasure::Statistics getExecStat();
    
    virtual TimeMeasure::Statistics getPeriodStat();
    
  protected:
    virtual int svc();

    virtual void sleep();

    virtual void updateExecStat();

    virtual void updatePeriodStat();

  protected:
    coil::TimeValue m_period;

    bool m_nowait;

    TaskFuncBase* m_func;

    bool m_deleteInDtor;

    class alive_t
    {
    public:
      alive_t(bool val) : value(val) {}
      bool value;
      coil::Mutex mutex;
    };

    alive_t m_alive;

    struct suspend_t
    {
      suspend_t(bool sus) : suspend(sus), mutex(), cond(mutex) {}
      bool suspend;
      coil::Mutex mutex;
      coil::Condition<coil::Mutex> cond;
    };

    suspend_t m_suspend;
      
    struct statistics_t
    {
      coil::TimeMeasure::Statistics stat;
      coil::Mutex mutex;
    };

    bool              m_execMeasure;

    unsigned int      m_execCount;

    unsigned int      m_execCountMax;

    statistics_t      m_execStat;

    coil::TimeMeasure m_execTime;

    bool              m_periodMeasure;

    unsigned int      m_periodCount;

    unsigned int      m_periodCountMax;

    statistics_t      m_periodStat;

    coil::TimeMeasure m_periodTime;

  };

}; // namespace coil

#endif // COIL_PERIODICTASK_H