ExecutionContextBase.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_EXECUTIONCONTEXTBASE_H
#define RTC_EXECUTIONCONTEXTBASE_H
 
#include <coil/Factory.h>
 
#include <rtm/idl/RTCSkel.h>
#include <rtm/idl/OpenRTMSkel.h>
#include <rtm/Factory.h>
#include <rtm/ExecutionContextProfile.h>
#include <rtm/ExecutionContextWorker.h>
 
#define DEFAULT_EXECUTION_RATE 1000
 
namespace coil
{
  class Properties;
} // namespace coil
 
namespace RTC
{
  class ExecutionContextBase
  {
  public:
    explicit ExecutionContextBase(const char* name);
 
    virtual ~ExecutionContextBase();
 
    virtual void init(coil::Properties& props);
 
    virtual RTC::ReturnCode_t bindComponent(RTC::RTObject_impl* rtc);
 
    //============================================================
    // implementation functions for EC's CORBA operation
    //============================================================
    CORBA::Boolean isRunning();
 
    RTC::ReturnCode_t start();
 
    virtual RTC::ReturnCode_t stop();
 
    double getRate() const;
    std::chrono::nanoseconds getPeriod() const;
 
    RTC::ReturnCode_t setRate(double rate);
 
    RTC::ReturnCode_t addComponent(RTC::LightweightRTObject_ptr comp);
 
    RTC::ReturnCode_t removeComponent(RTC::LightweightRTObject_ptr comp);
 
    RTC::ReturnCode_t activateComponent(RTC::LightweightRTObject_ptr comp);
 
    RTC::ReturnCode_t deactivateComponent(RTC::LightweightRTObject_ptr comp);
 
    RTC::ReturnCode_t resetComponent(RTC::LightweightRTObject_ptr comp);
 
    RTC::LifeCycleState getComponentState(RTC::LightweightRTObject_ptr comp);
    static const char* getStateString(RTC::LifeCycleState state);
 
    RTC::ExecutionKind getKind() const;
 
    RTC::ExecutionContextProfile* getProfile();
 
    //============================================================
    // Delegated functions to ExecutionContextProfile
    //============================================================
    void setObjRef(RTC::ExecutionContextService_ptr ec_ptr);
 
    RTC::ExecutionContextService_ptr getObjRef() const;
 
    static const char* getKindString(RTC::ExecutionKind kind) ;
 
    RTC::ReturnCode_t setKind(RTC::ExecutionKind kind);
 
    RTC::ReturnCode_t setOwner(RTC::LightweightRTObject_ptr comp);
 
    RTC::RTObject_ptr getOwner() const;
 
#ifndef ORB_IS_RTORB
    const RTC::RTCList& getComponentList() const;
#else
    const RTC_RTCList& getComponentList() const;
#endif
 
    void setProperties(coil::Properties& props);
 
    coil::Properties getProperties() const;
 
    const RTC::ExecutionContextProfile& getProfile() const;
    // end of delegated functions to ExecutionContextProfile
    //============================================================
 
    //============================================================
    // Delegated functions to ExecutionContextWorker
    //============================================================
    bool isAllCurrentState(RTC::LifeCycleState state)
    {
      return m_worker.isAllCurrentState(state);
    }
    bool isAllNextState(RTC::LifeCycleState state)
    {
      return m_worker.isAllNextState(state);
    }
    bool isOneOfCurrentState(RTC::LifeCycleState state)
    {
      return m_worker.isOneOfCurrentState(state);
    }
    bool isOneOfNextState(RTC::LifeCycleState state)
    {
      return m_worker.isOneOfNextState(state);
    }
 
    void invokeWorker()       { m_worker.invokeWorker(); }
    void invokeWorkerPreDo()  { m_worker.invokeWorkerPreDo(); }
    void invokeWorkerDo()     { m_worker.invokeWorkerDo(); }
    void invokeWorkerPostDo() { m_worker.invokeWorkerPostDo(); }
 
 
  protected:
    // template virtual functions related to start/stop
    virtual bool onIsRunning(bool running) { return running; }
    virtual RTC::ReturnCode_t onStarting() { return RTC::RTC_OK; }
    virtual RTC::ReturnCode_t onStarted() { return RTC::RTC_OK; }
    virtual RTC::ReturnCode_t onStopping() { return RTC::RTC_OK; }
    virtual RTC::ReturnCode_t onStopped() { return RTC::RTC_OK; }
 
    // template virtual functions getting/setting execution rate
    virtual double onGetRate(double rate) const { return rate; }
    virtual double onSettingRate(double rate) { return rate; }
    virtual RTC::ReturnCode_t onSetRate(double  /*rate*/) { return RTC::RTC_OK; }
 
    // template virtual functions adding/removing component
    virtual RTC::ReturnCode_t
    onAddingComponent(RTC::LightweightRTObject_ptr  /*rtobj*/)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onAddedComponent(RTC::LightweightRTObject_ptr  /*rtobj*/)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onRemovingComponent(RTC::LightweightRTObject_ptr  /*rtobj*/)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onRemovedComponent(RTC::LightweightRTObject_ptr  /*rtobj*/)
    {
      return RTC::RTC_OK;
    }
 
    // template virtual functions related to activation/deactivation/reset
    virtual RTC::ReturnCode_t
    onActivating(RTC::LightweightRTObject_ptr  /*comp*/)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onWaitingActivated(RTC_impl::RTObjectStateMachine*  /*comp*/, long int  /*count*/)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onActivated(RTC_impl::RTObjectStateMachine*  /*comp*/,
                                     long int  /*count*/)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onDeactivating(RTC::LightweightRTObject_ptr  /*comp*/)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onWaitingDeactivated(RTC_impl::RTObjectStateMachine*  /*comp*/, long int  /*count*/)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onDeactivated(RTC_impl::RTObjectStateMachine*  /*comp*/, long int  /*count*/)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t onResetting(RTC::LightweightRTObject_ptr  /*comp*/)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onWaitingReset(RTC_impl::RTObjectStateMachine*  /*comp*/, long int  /*count*/)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onReset(RTC_impl::RTObjectStateMachine*  /*comp*/, long int  /*count*/)
    {
      return RTC::RTC_OK;
    }
 
    virtual RTC::LifeCycleState
    onGetComponentState(RTC::LifeCycleState state)
    {
      return state;
    }
    virtual RTC::ExecutionKind
    onGetKind(RTC::ExecutionKind kind) const
    {
      return kind;
    }
    virtual RTC::ExecutionContextProfile*
    onGetProfile(RTC::ExecutionContextProfile*& profile)
    {
      return profile;
    }
 
  private:
    bool setExecutionRate(coil::Properties& props);
    bool setTransitionMode(coil::Properties& props,
                           const char* key, bool& flag);
    bool setTimeout(coil::Properties& props, const char* key,
                    std::chrono::nanoseconds& timevalue);
 
    RTC::ReturnCode_t waitForActivated(RTC_impl::RTObjectStateMachine* rtobj);
    RTC::ReturnCode_t waitForDeactivated(RTC_impl::RTObjectStateMachine* rtobj);
    RTC::ReturnCode_t waitForReset(RTC_impl::RTObjectStateMachine* rtobj);
 
  protected:
    mutable RTC::Logger rtclog;
 
    RTC_impl::ExecutionContextWorker m_worker;
    RTC_impl::ExecutionContextProfile m_profile;
 
    std::chrono::nanoseconds m_activationTimeout;
    std::chrono::nanoseconds m_deactivationTimeout;
    std::chrono::nanoseconds m_resetTimeout;
 
    bool m_syncActivation;
    bool m_syncDeactivation;
    bool m_syncReset;
  };  // class ExecutionContextBase
 
  using ExecutionContextFactory = coil::GlobalFactory<ExecutionContextBase>;
} // namespace RTC
 
#ifdef WIN32
EXTERN template class DLL_PLUGIN coil::GlobalFactory<RTC::ExecutionContextBase>;
#elif defined(__GNUC__)
EXTERN template class coil::GlobalFactory<RTC::ExecutionContextBase>;
#endif
 
#endif  // RTC_EXECUTIONCONTEXTBASE_H