PeriodicExecutionContext.h

[詳解]

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

#include <vector>
#include <iostream>

#include <coil/Task.h>
#include <coil/Mutex.h>
#include <coil/Condition.h>
#include <coil/Affinity.h>

#include <rtm/ExecutionContextBase.h>

#define NUM_OF_LIFECYCLESTATE 4

#ifdef WIN32
#pragma warning( disable : 4290 )
#endif

namespace RTC_exp
{
  class PeriodicExecutionContext
    : public virtual POA_RTC::ExecutionContextService,
      public virtual PortableServer::RefCountServantBase,
      public RTC::ExecutionContextBase,
      public coil::Task
  {
    typedef coil::Guard<coil::Mutex> Guard;
  public:
    PeriodicExecutionContext();

    virtual ~PeriodicExecutionContext(void);

    virtual  void init(coil::Properties& props);

    virtual int open(void *args);

    virtual int svc(void);

    virtual int close(unsigned long flags);

    //============================================================
    // ExecutionContext
    //============================================================
    virtual CORBA::Boolean is_running(void)
      throw (CORBA::SystemException);

    virtual RTC::ReturnCode_t start(void)
      throw (CORBA::SystemException);

    virtual RTC::ReturnCode_t stop(void)
      throw (CORBA::SystemException);

    virtual CORBA::Double get_rate(void)
      throw (CORBA::SystemException);

    virtual RTC::ReturnCode_t  set_rate(CORBA::Double rate)
      throw (CORBA::SystemException);

    virtual RTC::ReturnCode_t
    activate_component(RTC::LightweightRTObject_ptr comp)
      throw (CORBA::SystemException);
    
    virtual RTC::ReturnCode_t
    deactivate_component(RTC::LightweightRTObject_ptr comp)
      throw (CORBA::SystemException);

    virtual RTC::ReturnCode_t
    reset_component(RTC::LightweightRTObject_ptr comp)
      throw (CORBA::SystemException);

    virtual RTC::LifeCycleState
    get_component_state(RTC::LightweightRTObject_ptr comp)
      throw (CORBA::SystemException);

    virtual RTC::ExecutionKind get_kind(void)
      throw (CORBA::SystemException);

    virtual RTC::ReturnCode_t add_component(RTC::LightweightRTObject_ptr comp)
      throw (CORBA::SystemException);

    virtual RTC::ReturnCode_t
    remove_component(RTC::LightweightRTObject_ptr comp)
      throw (CORBA::SystemException);

    virtual RTC::ExecutionContextProfile* get_profile(void)
      throw (CORBA::SystemException);

  protected:
    template <class T>
    void getProperty(coil::Properties& prop, const char* key, T& value)
    {
      if (prop.findNode(key) != 0)
        {
          T tmp;
          if (coil::stringTo(tmp, prop[key].c_str()))
            {
              value = tmp;
            }
        }
    }
    virtual RTC::ReturnCode_t onStarted();
    virtual RTC::ReturnCode_t onStopping();
    // template virtual functions adding/removing component
     virtual RTC::ReturnCode_t
     onAddedComponent(RTC::LightweightRTObject_ptr rtobj);
    virtual RTC::ReturnCode_t
    onRemovedComponent(RTC::LightweightRTObject_ptr rtobj);

    virtual RTC::ReturnCode_t
    onWaitingActivated(RTC_impl::RTObjectStateMachine* comp, long int count);
    virtual RTC::ReturnCode_t
    onActivated(RTC_impl::RTObjectStateMachine* comp, long int count);
    virtual RTC::ReturnCode_t
    onWaitingDeactivated(RTC_impl::RTObjectStateMachine* comp, long int count);
    virtual RTC::ReturnCode_t 
    onDeactivated(RTC_impl::RTObjectStateMachine* comp, long int count);
    virtual RTC::ReturnCode_t
    onWaitingReset(RTC_impl::RTObjectStateMachine* comp, long int count);
    virtual RTC::ReturnCode_t 
    onReset(RTC_impl::RTObjectStateMachine* comp, long int count);

    virtual void setCpuAffinity(coil::Properties& props);

    bool threadRunning()
    {
      Guard guard(m_svcmutex);
      return m_svc;
    }
  protected:
    RTC::Logger rtclog;

    bool m_svc;
    coil::Mutex m_svcmutex;
    
    struct WorkerThreadCtrl
    {
      WorkerThreadCtrl() : cond_(mutex_), running_(false) {};
      coil::Mutex mutex_;
      coil::Condition<coil::Mutex> cond_;
      bool running_;
    };

    WorkerThreadCtrl m_workerthread;

    bool m_nowait;

    coil::CpuMask m_cpu;

  }; // class PeriodicExecutionContext
}; // namespace RTC

#ifdef WIN32
#pragma warning( default : 4290 )
#endif


extern "C"
{
  void PeriodicExecutionContextInit(RTC::Manager* manager);
};

#endif // RTC_PERIODICEXECUTIONCONTEXT_H