ExecutionContextWorker.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_EXECUTIONCONTEXTWORKER_H
#define RTC_EXECUTIONCONTEXTWORKER_H
 
#include <condition_variable>
 
#include <rtm/idl/RTCSkel.h>
#include <rtm/SystemLogger.h>
#include <vector>
 
#define NUM_OF_LIFECYCLESTATE 4
 
namespace RTC
{
  class RTObject_impl;
} // namespace RTC
namespace RTC_impl
{
  class RTObjectStateMachine;
  using LightweightRTObject_ptr = RTC::LightweightRTObject_ptr;
  using LightweightRTObject_var = RTC::LightweightRTObject_var;
  class ExecutionContextWorker
  {
 
  public:
    ExecutionContextWorker();
 
 
    virtual ~ExecutionContextWorker();
 
    //============================================================
    // Object reference to EC
    //============================================================
    void setECRef(RTC::ExecutionContextService_ptr ref);
    RTC::ExecutionContextService_ptr getECRef();
 
    //============================================================
    // ExecutionContext
    //============================================================
    CORBA::Boolean isRunning();
 
    RTC::ReturnCode_t start();
 
    RTC::ReturnCode_t stop();
 
    RTC::ReturnCode_t startThread();
 
    RTC::ReturnCode_t stopThread();
 
 
    RTC::ReturnCode_t rateChanged();
 
    RTC::ReturnCode_t activateComponent(RTC::LightweightRTObject_ptr comp,
                                        RTObjectStateMachine*& rtobj);
    RTC::ReturnCode_t waitActivateComplete(RTObjectStateMachine*& rtobj,
                                           std::chrono::nanoseconds timeout
                                           = std::chrono::seconds(1),
                                           long int cycle = 1000);
    RTC::ReturnCode_t deactivateComponent(RTC::LightweightRTObject_ptr comp,
                                          RTObjectStateMachine*& rtobj);
    RTC::ReturnCode_t waitDeactivateComplete(RTObjectStateMachine*& rtobj,
                                             std::chrono::nanoseconds timeout
                                             = std::chrono::seconds(1),
                                             long int cycle = 1000);
 
    RTC::ReturnCode_t resetComponent(RTC::LightweightRTObject_ptr comp,
                                     RTObjectStateMachine*& rtobj);
    RTC::ReturnCode_t waitResetComplete(RTObjectStateMachine*& rtobj,
                                        std::chrono::nanoseconds timeout
                                        = std::chrono::seconds(1),
                                        long int cycle = 1000);
 
    RTC::LifeCycleState getComponentState(RTC::LightweightRTObject_ptr comp);
    static const char* getStateString(RTC::LifeCycleState state)
    {
      static const char* const st[] = {
        "CREATED_STATE",
        "INACTIVE_STATE",
        "ACTIVE_STATE",
        "ERROR_STATE"
      };
      return state >= RTC::CREATED_STATE && state <= RTC::ERROR_STATE ?
        st[state] : "";
    }
    RTC::ReturnCode_t addComponent(RTC::LightweightRTObject_ptr comp);
 
    RTC::ReturnCode_t bindComponent(RTC::RTObject_impl* rtc);
 
    RTC::ReturnCode_t removeComponent(RTC::LightweightRTObject_ptr comp);
    RTObjectStateMachine* findComponent(RTC::LightweightRTObject_ptr comp);
 
    bool isAllCurrentState(RTC::LifeCycleState state);
    bool isAllNextState(RTC::LifeCycleState state);
    bool isOneOfCurrentState(RTC::LifeCycleState state);
    bool isOneOfNextState(RTC::LifeCycleState state);
 
    void invokeWorker();
    void invokeWorkerPreDo();
    void invokeWorkerDo();
    void invokeWorkerPostDo();
 
    void updateComponentList();
 
    //------------------------------------------------------------
    // member variables
  protected:
    RTC::Logger rtclog{"ec_worker"};
 
    RTC::ExecutionContextService_var m_ref;
 
    bool m_running{false};
 
    std::vector<RTC_impl::RTObjectStateMachine*> m_comps;
    mutable std::mutex m_mutex;
    std::vector<RTC_impl::RTObjectStateMachine*> m_addedComps;
    mutable std::mutex m_addedMutex;
    std::vector<RTC_impl::RTObjectStateMachine*> m_removedComps;
    mutable std::mutex m_removedMutex;
    using CompItr = std::vector<RTC_impl::RTObjectStateMachine*>::iterator;
 
  };  // class PeriodicExecutionContext
} // namespace RTC_impl
 
#endif  // RTC_PERIODICEXECUTIONCONTEXT_H